APIO2017伪题解

题目质量还是比较高的，只是当时澳大利亚方面出了一点问题？最后造成了区分度非常迷的局面。

纵观三道题，T1是披着交互外衣的提答题，T2是披着交互外衣的传统题，T3是一道据说近年来APIO最水的一道传统题，然而对于不敢相信T3水的选手来说只能靠硬搞两道交互拿分了。

T1 Rainbow

没脸写题解和程序了。

Subtask 1直接floodfill一下，Subtask 2听说前缀和讨论一下，后面听说数据结构维护一下。

T2 Koala

这个感觉可以写一篇交互库玩耍记了，感觉前几个部分分就是在考调戏交互库的水平。

首先看Subtask 1只有4分，而且场上超过300人拿了这4分，但是我不会怎么办？

猜一个结论，随便选一个旁边放一个宝石，其它都不放，然后koala没放宝石的那个就是最小的那个。就过了。（我竟然没想到）

然后如果光搞Subtask 2感觉想得出结论会比较吃力，因为这题实际上是一道构造题。这个时候就需要在交互库上做文章了。

看一会代码发现交互库实际上就是一个无脑DP（于是就可以确定交互库占用的时空复杂度了），并没有什么可以利用的地方。但是我们可以把它改成一个能够做实验的程序，可供我们猜结论使用，如下

 #include<cstdio>
 #include<ctime>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 using namespace std;

 int N,W,P[],b[],r[],c[];

 void playRound(int *B, int *R) {
     int i, j;

     int cache[][];
     int num[][];
     char taken[][];

     for (i=;i<;++i) {
         cache[][i] = ;
         num[][i] = ;
     }

     for (i=;i<N;++i) {
         int v = B[i]+;
         int ii = i&;
         int o = ii^;
         for (j=;j<=W;++j) {
             cache[ii][j] = cache[o][j];
             num[ii][j] = num[o][j];
             taken[i][j] = ;
         }
         for (j=W;j>=v;--j) {
             int h = cache[o][j-v] + P[i];
             int hn = num[o][j-v] + ;
             if (h > cache[ii][j] || (h == cache[ii][j] && hn > num[ii][j])) {
                 cache[ii][j] = h;
                 num[ii][j] = hn;
                 taken[i][j] = ;
             } else {
                 taken[i][j] = ;
             }
         }
     }

     int cur = W;
     for (i=N-;i>=;--i) {
         R[i] = taken[i][cur] ? (B[i] + ) : ;
         cur -= R[i];
     }
 }

 int main(){
     srand(time(NULL));
     N=; W=;
     for (int i=; i<N; i++){
         int k=rand()%N+; while (c[k]) k=rand()%N+;
         c[k]=; P[i]=k;
     }

     b[]=b[]=;
     for (int i=; i<; i++) b[i]=;

     playRound(b,r);
     for (int i=; i<N; i++){
         printf("%3d%3d ",i,r[i]);
         if ((i+)%==) puts("");
     }
     return ;
 }

对于如何分配b数组，只需要改主函数里的两句话即可。

通过实验发现，现在已经确定的区间为[1,100]，如果每个位置放一个的话，就可以确定[51,100]，然后这部分放2个其余都不放的话可以确定[76,100]，这部分再放4个其余不放的话可以确定[92,100]，这部分放11个可以确定[100,100]。

这样我们真好用了4次确定了100的位置。

考虑如何测试，写一个数据生成程序：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<sys/timeb.h>
 #include<cstdlib>
 #include<fstream>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 typedef long long ll;
 using namespace std;

 ofstream fout,fres;

 const int N=;
 int b[N];

 void insd(){
     struct timeb tp; ftime(&tp);
     srand(tp.time*+tp.millitm);
 }

 int sj(int l,int r){ return rand()%(r-l+)+l; }

 int main(){
     insd();
     fout.open("koala.in"); fres.open("result");
     ios::sync_with_stdio(false);

     int F=sj(,),G=sj(,);
     fout<<F<<' '<<G<<endl;
     if (F==){
         while (G--){
             fout<<"100 100 ";
             rep(i,,) b[i]=;
             rep(i,,){
                 int k=sj(,); while (b[k]) k=sj(,);
                 fout<<k<<' '; b[k]=;
                 if (k==) fres<<i<<endl;
             }
             fout<<endl;
         }
     }else if (F==){
         while (G--){
             fout<<"100 100 ";
             rep(i,,) b[i]=;
             rep(i,,){
                 int k=sj(,); while (b[k]) k=sj(,);
                 fout<<k<<' '; b[k]=;
                 if (k==) fres<<i<<endl;
             }
             fout<<endl;
         }
     }else if (F==){
         while (G--){
             int x=,y=;
             fout<<"100 100 ";
             rep(i,,) b[i]=;
             rep(i,,){
                 int k=sj(,); while (b[k]) k=sj(,);
                 fout<<k<<' '; b[k]=;
                 if (!x) x=k; else if (!y) fres<<((k>x)?:)<<endl,y=k;
             }
             fout<<endl;
         }
     }
     fout.close(); fres.close();
     return ;
 }

这份代码在生成数据的同时将答案输出到了result文件里，方便对拍。对拍的代码：

 g++ make.cpp -o make -g -Wall
 g++ koala.cpp grader.cpp -o koala -static -std=c++
 while true; do
 echo ---------------------
 ./make
 time ./koala<koala.in>koala.out
 if !(diff -w koala.out result); then exit; fi
 done

现在看Subtask 3，用上面的程序实验发现，其余都不放，如果b[0]和b[1]都放15的话，两个都不会被选。这样我们在[1,15]内二分，每次保证b[0]=b[1]，直到发现有一个选了而另一个没选就可以返回答案了。

这是C<=4的算法，能拿14分，满分是将区间人工细化以减小一次机器搜索。

前33分程序：

 #include "koala.h"
 #include<cstdio>
 using namespace std;

 const int N=;
 int b[N],r[N],c[N];

 int minValue(int N, int W) {
     for (int i=; i<N; i++) b[i]=; b[]=;
     playRound(b,r);
     for (int i=; i<N; i++) if (!r[i]) return i;
     return ;
 }

 int maxValue(int N, int W) {
     for (int i=; i<N; i++) b[i]=,c[i]=;
     playRound(b,r);
     for (int i=; i<N; i++) if (!r[i]) c[i]=;
     for (int i=; i<N; i++) if (!c[i]) b[i]=; else b[i]=;
     playRound(b,r);
     for (int i=; i<N; i++) if (r[i]!=) c[i]=;
     for (int i=; i<N; i++) if (!c[i]) b[i]=; else b[i]=;
     playRound(b,r);
     for (int i=; i<N; i++) if (r[i]!=) c[i]=;
     for (int i=; i<N; i++) if (!c[i]) b[i]=; else b[i]=;
     playRound(b,r);
     for (int i=; i<N; i++) if (r[i]==) return i;
     return ;
 }

 int greaterValue(int N, int W) {
     int L=,R=;
     while (L<R){
         int mid=(L+R)>>;
         b[]=b[]=mid;
         for (int i=; i<N; i++) b[i]=;

         playRound(b,r);

         if (!r[] && r[]) return ;
         if (!r[] && r[]) return ;

         if (!r[] && !r[]) R=mid-; else L=mid+;
     }
     return L;
 }

 void allValues(int N, int W, int *P) { if (W == *N) { } else { } }

Subtask 4是给数组排序，发现如果b[x]和b[y]各放100个的话，肯定有一个被选而另一个不选，也就是说可以用一次游戏完成两个数的比较。

所以我们手工实现一个$O(n\log n)$的比较排序算法即可。

或许可以直接写进std::sort的cmp里，没试过。

Subtask 5没做。

T3 merchant

首先第一眼分数规划，第二眼spfa判负环，问题解决了一半。

然后发现因为每次买卖涉及两个城市，所以一般做法没办法给每条边赋值。

考虑根据决策重建图，如果两个点u和v又一次买卖，一定是u的买入价和v的卖出价中差值最大的那个，所以根据这个连边，构成一个边数$n^2$的图，就可以直接跑spfa了。

比较坑的情况是一个城市同一个商品的卖出价可能大于买入价，也就是说留在这里不走可以一直赚钱。但题目显然是不允许这样的。

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 typedef long long ll;
 using namespace std;

 const int N=,M=,inf=;
 int n,m,K,u,v,w,mx,flag,mid,vis[N],val[N][N],mp[N][N],a[N][M],b[N][M];
 ll d[N];

 void spfa(int x){
     if (flag) return; vis[x]=;
     rep(i,,n) if (i!=x && mp[x][i]<inf && d[i]>d[x]+1ll*mp[x][i]*mid-val[x][i]){
         d[i]=d[x]+1ll*mp[x][i]*mid-val[x][i];
         if (vis[i]) { flag=; return; } else spfa(i);
     }
     vis[x]=;
 }

 int jud(int mid){
     rep(i,,n) vis[i]=d[i]=; flag=;
     rep(i,,n){ spfa(i); if (flag) return ; }
     return ;
 }

 int main(){
     freopen("merchant.in","r",stdin);
     freopen("merchant.out","w",stdout);
     scanf("%d%d%d",&n,&m,&K);
     rep(i,,n) rep(j,,K) scanf("%d%d",&a[i][j],&b[i][j]),mx=max(mx,b[i][j]);
     rep(i,,n) { rep(j,,n) mp[i][j]=inf; mp[i][i]=; }
     rep(i,,m) scanf("%d%d%d",&u,&v,&w),mp[u][v]=min(mp[u][v],w);
     rep(k,,n) rep(i,,n) rep(j,,n) mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
     rep(i,,n) rep(j,,n) rep(k,,K)
         if (i!=j && ~a[i][k] && ~b[j][k]) val[i][j]=max(val[i][j],b[j][k]-a[i][k]);
     int L=,R=mx,ans=;
     while (L<=R){
         mid=(L+R)>>;
         if (jud(mid)) ans=mid,L=mid+; else R=mid-;
     }
     printf("%d\n",ans);
     return ;
 }