ZOJ 3703，3700，3699

经典背包问题，处理好限制条件的优先级

排序是为了让相同val，相同问题数量以及选择的时候，从ti更小的问题坐起，总的penalty会最少

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <map>
#include <algorithm>
#include <string>
using namespace std;
struct Point
{
int t,v;
}p[55];
bool cmp(Point left,Point right)
{
return left.t<right.t;
}
int dp[1005],pen[1005],pro[1005];
int main ()
{
int test;scanf("%d",&test);
while(test--)
{
int len,n;
scanf("%d%d",&len,&n);
memset(dp,0,sizeof(dp));
memset(pro,0,sizeof(pro));
memset(pen,0,sizeof(pen));
for(int i=1;i<=n;++i)
scanf("%d",&p[i].t);
for(int i=1;i<=n;++i)
scanf("%d",&p[i].v);
int ans_val=0,ans_p=0,penalty=0;
sort(p+1,p+1+n,cmp);
for(int i=1;i<=n;++i)
{
for(int j=len;j>=p[i].t;--j)
{
bool flag=false;
if(dp[j-p[i].t]+p[i].v>dp[j])
flag=true;
else if(dp[j-p[i].t]+p[i].v==dp[j] && pro[j-p[i].t]+1>pro[j])
flag=true;
else if(dp[j-p[i].t]+p[i].v==dp[j] && pro[j-p[i].t]+1==pro[j] && pen[j-p[i].t]+j<pen[j])
flag=true;
if(flag) // update
{
dp[j]=dp[j-p[i].t]+p[i].v;
pro[j]=pro[j-p[i].t]+1;
pen[j]=pen[j-p[i].t]+j;

}
}
}
for(int j=0;j<=len;++j)
{
bool flag=false;
if(ans_val<dp[j])
flag=true;
else if(ans_val==dp[j] && ans_p<pro[j])
flag=true;
else if(ans_val==dp[j] && ans_p<pro[j] && penalty>pen[j])
flag=true;
if(flag)
{
ans_val=dp[j];
ans_p=pro[j];
penalty=pen[j];
}
}
printf("%d %d %d\n",ans_val,ans_p,penalty);

}
return 0;
}

3700

直接模拟，对set不熟悉，调试到半死，过程中出现"map/set iterator not incrementable"以为是set语法错了，查了好久set的资料，都发现没问题

其实是string读取除了问题，把空字符串放进set里面，dereference时出错了，

然后排序的问题也搞错了

学习了：

set自定义排序方式，原来要自定义个struct，重载运算符，写法好神奇

string各种错

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include<iterator>
#include <algorithm>
#include <string>
using namespace std;
struct Cmp
{
bool operator()(const string& a,const string &b) const
{
if(a.length()==b.length())
{
return a<b;
}
return a.length()<b.length();
}
};
int n;
map<string,int>mt;
map<string,int>::iterator iter;
set<string,Cmp>::iterator siter,nxt;
set<string,Cmp>s[5005];
char ss[1000];
char temp[105];

int main ()
{
/*s[1].insert("fdsfd");
s[1].insert("fdd");
for(siter=s[1].begin();siter!=s[1].end();++siter)
cout<<*siter<<endl;
system("pause");*/
int test;scanf("%d",&test);
while(test--)
{
mt.clear();
scanf("%d",&n);
gets(ss);
string tt;
int ma=-1;
for(int i=1;i<=n;++i)
{
gets(ss);
int len=strlen(ss);
for(int j=0;j<len;++j)
if(ss[j]>='A'&&ss[j]<='Z')
ss[j]+=32;
else if(!(ss[j]>='a'&&ss[j]<='z'))
ss[j]='\0';
for(int j=0;j<len;)
{
while(ss[j]=='\0' && j<len)
j++;
if(j>=len)
break;
sscanf(ss+j,"%s",temp);
tt=temp;
if(tt=="")
j++;
else
{
mt[tt]++;
ma=max(ma,mt[tt]);
j+=tt.length();
}
}
}

for(int i=1;i<=ma;++i)
s[i].clear();
for(iter=mt.begin();iter!=mt.end();++iter)
{
s[iter->second].insert(iter->first);
}

bool pre=false;
for(int i=ma;i>=2;--i)
{
if(s[i].size()==0)
continue;
if(s[i].size()==1)
{
if(pre)
printf(" ");
cout<<s[i].begin()->c_str();
pre=true;
}
else
{
nxt=siter=s[i].end();
nxt--;siter--;siter--;
if(pre)
printf(" ");
if((*siter).length()<(*nxt).length())
cout<<*nxt;
else cout<<*siter;
pre=true;
}
}
puts("");
}
return 0;
}

ZOJ 3699

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include<iterator>
#include <algorithm>
#include <string>
using namespace std;
#define N 100500
#define ll long long
struct Node
{
ll vol,p;
}q
;
ll pr
,gas
,cap;
int n;

int main ()
{
int test;scanf("%d",&test);
while(test--)
{
scanf("%d%lld",&n,&cap);
bool flag=true;
ll x,y;
for(int i=1;i<=n;++i)
{
scanf("%lld%lld%lld",&x,&y,&pr[i]);
gas[i]=x*y;
if(gas[i]>cap)
flag=false;
}
if(!flag)
{
printf("Impossible\n");
continue;
}
int top=0,front=1;
ll now=0,ans=0;
for(int i=1;i<=n;++i)
{
while(pr[i]<q[top].p)
{
now-=q[top].vol;
q[top].p=q[top].vol=0;
top--;
}
++top;
q[top].p=pr[i];
q[top].vol=cap-now;
now=cap;
ll need=gas[i];
now-=need;
while(need>0)
{
if(need>=q[front].vol)
{
need-=q[front].vol;
ans+=q[front].p*q[front].vol;
q[front].p=q[front].vol=0;
front++;
}
else
{
ans+=q[front].p*need;
q[front].vol-=need;
need=0;
}
}
}
printf("%lld\n",ans);
}
return 0;
}