CF132E Bits of merry old England

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

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

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

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

 

#include <bits/stdc++.h>

const int N = 1010, INF = 0x3f3f3f3f;

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

int X[N];

struct Node {
    int p, v;
    bool f; /// 0 print  1 change
    Node(int P = 0, int V = 0, bool F = 0) {
        p = P;
        v = V;
        f = F;
    }
    inline void out() {
        if(!f) {
            printf("print("); putchar('a' + p - 1); printf(")\n");
        }
        else {
            putchar('a' + p - 1); 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 : 0;
    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, 0, -w);
    e[y] = tp;
    return;
}

inline bool SPFA(int s, int t) {
    static int Time = 0; ++Time;
    memset(d, 0x3f, sizeof(d));
    Q.push(s);
    vis[s] = Time;
    flow[s] = INF;
    d[s] = 0;
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        vis[x] = 0;
//        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 ^ 1].c += f;
        t = edge[i ^ 1].v;
//        printf("%d ", t);
    }
//    printf("\n");
    return;
}

inline int solve(int s, int t, int &cost) {
    int ans = 0; cost = 0;
//    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 = 1; 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 + 1, X + n + 1);
    xx = std::unique(X + 1, X + n + 1) - X - 1;
//    printf("xx = %d \n", xx);
    for(int i = 1; i <= n; i++) {
        a[i] = std::lower_bound(X + 1, X + xx + 1, a[i]) - X;
//        printf("a %d = %d \n", i, a[i]);
    }
    for(int i = n; i >= 1; i--) {
        nex[i] = Last[a[i]];
        Last[a[i]] = i;
    }
    /// add edge
    
    int s = n * 3 + 2, t = s + 1, ss = s + 2, tt = s + 3;
    for(int i = 1; i <= n; i++) {
//        add(i, i + n, [1, 1], 0);
        in[i + n]++; in[i]--;
        add(i + 2 * n, i, 1, val[i]);
        add(i + n, i + 1 + 2 * n, 1, 0);
        add(i + 2 * n, i + 1 + 2 * n, INF, 0); 
        if(nex[i]) {
            add(i + n, nex[i], 1, 0);
//            printf("nex %d = %d  add(%d %d)\n", i, nex[i], i + n, nex[i]);
        }
    }
    add(s, 1 + 2 * n, m, 0);
    add(n + 1 + 2 * n, t, m, 0);
    int Ck = tp;
    add(t, s, INF, 0);
    for(int i = 1; i <= t; i++) {
        if(in[i]) {
            if(in[i] > 0) {
                add(ss, i, in[i], 0);
            }
            else  {
                add(i, tt, -in[i], 0);
            }
        }
    }
    
    int cost1 = 0, cost2 = 0;
    solve(ss, tt, cost1);
    for(int i = Ck + 1; i <= tp; i++) {
        edge[i].c = 0;
    }
    solve(s, t, cost2);
    
    // get ways
    for(int i = 1; i <= m; i++) {
        Q.push(i);
    }
    for(int j = 1; j <= n; j++) {
        int x = j + 2 * n;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(y == j && edge[i ^ 1].c) {
                /// a num -> a[j]
                tag[j] = Q.front();
                Q.pop();
                stk[++top] = Node(tag[j], a[j], 1);
                break;
            }
        }
//        printf("tag[j] = %d \n", tag[j]);
        stk[++top] = Node(tag[j], 0, 0);
        x = j + n;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(y == nex[j] && edge[i ^ 1].c) {
                tag[nex[j]] = tag[j];
                break;
            }
            if(y == j + 1 + 2 * n && edge[i ^ 1].c) {
                /// return queue
                Q.push(tag[j]);
                break;
            }
        }
    }
    
    printf("%d %d\n", top, cost1 + cost2);
    for(int i = 1; i <= top; i++) stk[i].out();
    return 0;
}