CF132E Bits of merry old England

解：略一思索：网络流啊！(别问我是怎么想到的......)

发现跟志愿者招募有点像。于是把图建一下，在下面开一条通道，但是每个点又都要经过，这时我们就无脑上下界一波。

通道向点连边，有费用。每个点向它下一次出现的点连边，费用0。每个点还向通道连边，费用0。

上下界费用流跑一下就出来费用了。然后是输出方案，看哪些边有流量，直接模拟。

 #include <bits/stdc++.h>

 const int N = , INF = 0x3f3f3f3f;

 struct Edge {
     int nex, v, c, len;
     Edge(int Nex = , int V = , int C = , int L = ) {
         nex = Nex;
         v = V;
         c = C;
         len = L;
     }
 }edge[]; int tp = ;

 int X[N];

 struct Node {
     int p, v;
     bool f; /// 0 print  1 change
     Node(int P = , int V = , bool F = ) {
         p = P;
         v = V;
         f = F;
     }
     inline void out() {
         if(!f) {
             printf("print("); putchar('a' + p - ); printf(")\n");
         }
         else {
             putchar('a' + p - ); printf("=%d\n", X[v]);
         }
         return;
     }
 }stk[N]; int top;

 int xx, Last[N], nex[N], in[N], e[N], tag[N];
 int n, m, a[N], val[N], pre[N], vis[N], flow[N], d[N];
 std::queue<int> Q;

 inline void Max(int &a, const int &b) {
     a < b ? a = b : ;
     return;
 }

 inline void add(int x, int y, int z, int w) {
 //    printf("add : %d %d %d %d\n", x, y, z, w);
     edge[++tp] = Edge(e[x], y, z, w);
     e[x] = tp;
     edge[++tp] = Edge(e[y], x, , -w);
     e[y] = tp;
     return;
 }

 inline bool SPFA(int s, int t) {
     static int Time = ; ++Time;
     memset(d, 0x3f, sizeof(d));
     Q.push(s);
     vis[s] = Time;
     flow[s] = INF;
     d[s] = ;
     while(!Q.empty()) {
         int x = Q.front();
         Q.pop();
         vis[x] = ;
 //        printf("  x = %d  d[x] = %d \n", x, d[x]);
         for(int i = e[x]; i; i = edge[i].nex) {
             int y = edge[i].v;
             if(d[y] > d[x] + edge[i].len && edge[i].c) {
                 d[y] = d[x] + edge[i].len;
 //                printf("    y = %d  d[y] = %d \n", y, d[y]);
                 flow[y] = std::min(flow[x], edge[i].c);
                 pre[y] = i;
                 if(vis[y] != Time) {
                     vis[y] = Time;
                     Q.push(y);
                 }
             }
         }
     }
     return d[t] < INF;
 }

 inline void update(int s, int t) {
     int f = flow[t];
 //    printf("update : %d ", t);
     while(t != s) {
         int i = pre[t];
         edge[i].c -= f;
         edge[i ^ ].c += f;
         t = edge[i ^ ].v;
 //        printf("%d ", t);
     }
 //    printf("\n");
     return;
 }

 inline int solve(int s, int t, int &cost) {
     int ans = ; cost = ;
 //    printf("solve : %d %d \n", s, t); int i = 0;
     while(SPFA(s, t)) {
 //        printf("loop : %d flow = %d d = %d \n", ++i, flow[t], d[t]);
         ans += flow[t];
         cost += flow[t] * d[t];
         update(s, t);
     }
 //    printf("ans = %d cost = %d\n", ans, cost);
     return ans;
 }

 /*
 7 2
 1 2 2 4 2 1 2
 ------------- 11 4
 6 3
 1 2 3 1 2 3
 -------------  9 4
 */

 int main() {
     scanf("%d%d", &n, &m);
     for(int i = ; i <= n; i++) {
         scanf("%d", &a[i]);
         int x = a[i];
         while(x) {
             x -= x & (-x);
             val[i]++;
         }
         X[i] = a[i];
     }
     std::sort(X + , X + n + );
     xx = std::unique(X + , X + n + ) - X - ;
 //    printf("xx = %d \n", xx);
     for(int i = ; i <= n; i++) {
         a[i] = std::lower_bound(X + , X + xx + , a[i]) - X;
 //        printf("a %d = %d \n", i, a[i]);
     }
     for(int i = n; i >= ; i--) {
         nex[i] = Last[a[i]];
         Last[a[i]] = i;
     }
     /// add edge

     int s = n *  + , t = s + , ss = s + , tt = s + ;
     for(int i = ; i <= n; i++) {
 //        add(i, i + n, [1, 1], 0);
         in[i + n]++; in[i]--;
         add(i +  * n, i, , val[i]);
         add(i + n, i +  +  * n, , );
         add(i +  * n, i +  +  * n, INF, );
         if(nex[i]) {
             add(i + n, nex[i], , );
 //            printf("nex %d = %d  add(%d %d)\n", i, nex[i], i + n, nex[i]);
         }
     }
     add(s,  +  * n, m, );
     add(n +  +  * n, t, m, );
     int Ck = tp;
     add(t, s, INF, );
     for(int i = ; i <= t; i++) {
         if(in[i]) {
             if(in[i] > ) {
                 add(ss, i, in[i], );
             }
             else  {
                 add(i, tt, -in[i], );
             }
         }
     }

     int cost1 = , cost2 = ;
     solve(ss, tt, cost1);
     for(int i = Ck + ; i <= tp; i++) {
         edge[i].c = ;
     }
     solve(s, t, cost2);

     // get ways
     for(int i = ; i <= m; i++) {
         Q.push(i);
     }
     for(int j = ; j <= n; j++) {
         int x = j +  * n;
         for(int i = e[x]; i; i = edge[i].nex) {
             int y = edge[i].v;
             if(y == j && edge[i ^ ].c) {
                 /// a num -> a[j]
                 tag[j] = Q.front();
                 Q.pop();
                 stk[++top] = Node(tag[j], a[j], );
                 break;
             }
         }
 //        printf("tag[j] = %d \n", tag[j]);
         stk[++top] = Node(tag[j], , );
         x = j + n;
         for(int i = e[x]; i; i = edge[i].nex) {
             int y = edge[i].v;
             if(y == nex[j] && edge[i ^ ].c) {
                 tag[nex[j]] = tag[j];
                 break;
             }
             if(y == j +  +  * n && edge[i ^ ].c) {
                 /// return queue
                 Q.push(tag[j]);
                 break;
             }
         }
     }

     printf("%d %d\n", top, cost1 + cost2);
     for(int i = ; i <= top; i++) stk[i].out();
     return ;
 }

AC代码