Educational Codeforces Round 29（6/7）

1、Quasi-palindrome

　　题意：问一个字符串（你可以添加前导‘0’或不添加）是否是回文串

　　思路：将给定的字符串的前缀‘0’和后缀‘0’都去掉，然后看其是否为回文串

 #include<iostream>
 using namespace std;
 int main()
 {
     int num;
     scanf("%d", &num);
     while (num /  !=  && num %  == ) num /= ;
     int tmp = ;
     int tnum = num;
     while (tnum)
     {
         tmp = tmp *  + tnum % ;
         tnum /= ;
     }
     if (tmp == num) printf("YES\n");
     else printf("NO\n");

     return ;
 }

2、Kayaking

　　题意：给出2*n个人的体重，有n-1辆双人车和2辆单人车，问每辆双人车上两个人的体重之差的和最小是多少

　　思路：先把体重从小到大排序，然后枚举不坐双人车的两个人，算出剩下的人的最小体重差的和，取最小值。

 #include<iostream>
 #include<algorithm>
 using namespace std;
 int wt[];
 const int INF = 1e9;
 int main()
 {
     int n;
     scanf("%d", &n);
     for (int i = ; i <=  * n; i++)
     {
         scanf("%d", &wt[i]);
     }
     sort(wt + , wt +  * n + );

     int sum = INF;
     for (int i = ; i <  * n; i++)
     {
         for (int j = i + ; j <=  * n; j++)
         {
             int tsum = ;
             for (int k = ; k <=  * n;)
             {
                 while(k == i||k==j)
                 {
                     k++;
                 }
                 int w1 = wt[k];
                 k++;
                 while(k == j||k==i)
                 {
                     k++;
                 }
                 tsum += wt[k] - w1;
                 k++;
             }
             sum = min(sum, tsum);
         }
     }
     printf("%d\n", sum);
     return ;
 }

3、1-2-3

　　题意：给出Alice和Bob的出拳依据及他们第一次的出拳，问k轮后Alice和Bob的得分

　　思路：找到循环节。

 #include<iostream>
 #include<map>
 using namespace std;
 int alice[][];
 int bob[][];
 map<pair<int, int>, int>mp;
 map<int, pair<int, int> >score;
 int  a, b;
 long long k;
 int main()
 {
     scanf("%I64d%d%d", &k, &a, &b);
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             scanf("%d", &alice[i][j]);
             alice[i][j]--;
         }
     }
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             scanf("%d", &bob[i][j]);
             bob[i][j]--;
         }
     }
     int apoint = , bpoint = ;
     int prea, preb;
     int kk = ;
     int T,ta,tb,st;
     a--, b--;
     while (kk < k)
     {
         if (kk == )
         {
             prea = a;
             preb = b;
             if (a ==  && b == || a==  && b == ||a==&&b==) apoint++;
             else if (b ==  && a ==  || b ==  && a ==  || b ==  && a == )bpoint++;
             mp[make_pair(a, b)] = ++kk;
         }
         else
         {
             int aa = alice[prea][preb], bb = bob[prea][preb];
             if (st=mp[make_pair(aa, bb)])
             {
                 T = kk - st + ;
                 pair<int, int>t1, t2;
                 if (T == )
                 {
                     t1 = score[st];
                     if (st > )
                     {
                         t2 = score[st - ];
                         ta = t1.first - t2.first;
                         tb = t1.second - t2.second;
                     }
                     else
                     {
                         ta = t1.first, tb = t1.second;
                     }
                 }
                 else
                 {
                     if (st > )
                     {
                         t1 = score[st - ];
                         t2 = score[kk];
                         ta = t2.first - t1.first;
                         tb = t2.second - t1.second;
                     }
                     else
                     {
                         t1 = score[kk];
                         ta = t1.first, tb = t1.second;
                     }
                 }
                 break;
             }
             if (aa ==  && bb ==  || aa ==  && bb ==  || aa ==  && bb == ) apoint++;
             else if (bb ==  && aa ==  || bb ==  && aa ==  || bb ==  && aa == )bpoint++;
             mp[make_pair(aa, bb)] = ++kk;
             prea = aa, preb = bb;
         }
         score[kk] = make_pair(apoint, bpoint);
     }
     if (kk == k) printf("%d %d\n", apoint, bpoint);
     else
     {
         long long suma = , sumb = ;
         if (st == ) suma += 1ll*k / T*ta, sumb += 1ll*k / T*tb;
         else
         {
             pair<int, int>tmp = score[st - ];
             suma += tmp.first, sumb += tmp.second;
             k -= st-;
             suma += 1ll * k / T*ta, sumb += 1ll * k / T*tb;
         }
         if (k%T)
         {
             if (st == )
             {
                 pair<int, int>t = score[k%T];
                 suma += t.first, sumb += t.second;
             }
             else
             {
                 pair<int, int>t1 = score[st-];
                 pair<int, int>t2 = score[k%T+st-];
                 suma += t2.first - t1.first, sumb += t2.second - t1.second;
             }
         }
         printf("%I64d %I64d\n", suma, sumb);
     }
     return ;
 }

4、Yet Another Array Queries Problem

　　题意：对数组进行两种操作：1是将某个区间内的数左移（最左边移到的移到最右边）；2是将某个区间内的数反转。给出初始数组和若干操作后，问若干下标位置的数是谁

　　思路：对每一个所询问的下边的数，从最后一次操作向前找其对应的初始数组的下标。

 #include<iostream>
 using namespace std;
 int a[];
 struct node
 {
     int ff;
     int ll;
     int rr;
 }qq[];
 int main()
 {
     int n, q, m;
     scanf("%d%d%d", &n, &q, &m);
     for (int i = ; i <= n; i++) scanf("%d", &a[i]);
     for (int i = ; i <= q; i++) scanf("%d%d%d", &qq[i].ff, &qq[i].ll, &qq[i].rr);
     for (int i = ; i <= m; i++)
     {
         int pos;
         scanf("%d", &pos);
         for (int j = q; j >= ; j--)
         {
             if (pos >= qq[j].ll&&pos <= qq[j].rr)
             {
                 if (qq[j].ff == )
                 {
                     if (pos > qq[j].ll) pos--;
                     else pos = qq[j].rr;
                 }
                 else
                 {
                     pos = qq[j].rr - (pos - qq[j].ll);
                 }
             }
         }
         if (i > ) printf(" ");
         printf("%d", a[pos]);
     }
     printf("\n");
     return ;
 }

5、Turn Off The TV

　　题意：有若干个区间，现在需要确定是否有多余的区间，使得在去掉这些区间后原本至少被一个区间覆盖的总长度不会减少。若存在，输出任意一个满足条件的区间的编号。

　　思路：把区间按左端点排序，如果当前区间的右端点小于等于当前的最右端，则该区间就是多余区间；否则，如果当前区间的左端点比当前最右端还要大，则更新当前区间最左端和当前区间最右端；否则，如果当前区间的下一个区间和当前最左端和最右端构成的区间能够覆盖当前区间，则当前区间就是多余区间。

 #include<iostream>
 #include<algorithm>
 using namespace std;
 struct node
 {
     int ll;
     int rr;
     int idx;
 }tv[];
 bool Cmp(const node&a, const node&b)
 {
     if (a.ll == b.ll) return a.rr > b.rr;
     else return a.ll < b.ll;
 }
 int main()
 {
     int n;
     scanf("%d", &n);
     for (int i = ; i < n; i++)
     {
         scanf("%d%d", &tv[i].ll, &tv[i].rr);
         tv[i].idx = i + ;
     }
     sort(tv, tv + n, Cmp);
     int ans = -;
     int tl = tv[].ll, tr = tv[].rr;
     for (int i = ; i < n; i++)
     {
         if (tv[i].rr <= tr)
         {
             ans = i;
             break;
         }
         else if (tv[i].ll > tr)
         {
             tl = tv[i].ll;
             tr = tv[i].rr;
         }
         else
         {
             if (i +  < n&&tv[i + ].ll <= tr+&&tv[i + ].rr >= tv[i].rr)
             {
                 ans = i;
                 break;
             }
             else
             {
                 tl = tv[i].ll;
                 tr = tv[i].rr;
             }
         }
     }
     if (ans == -) printf("-1\n");
     else printf("%d\n", tv[ans].idx);
     return ;
 }

6、Almost Permutation

　　题意：你现在知道若干区间内的数是大于等于某一个数还是小于等于某一个数，然后定义cost为数组中每个数出现的次数的平方和，问最小的cost.

　　思路：最小费用最大流。当所有条件都符合时（没有矛盾），将源点和每个index相连，容量为1，花费为0；将每个index和该index能够填的数字相连，容量为1，花费为0；对于每个数字，和汇点连n条边，容量1，花费为1、3、5、……、n*n-(n-1)(n-1)(如果当前这个数字出现k次，则需要向汇点连k条边，由于最小费用，肯定取最小花费的k条，由于前x条花费之和=x^2,即题目所要求的)

 #include<iostream>
 #include<algorithm>
 #include<queue>
 #include<cstring>
 using namespace std;
 int maxlv[];
 int minlv[];
 int cnt[];
 struct pp
 {
     int l;
     int r;
     int len;
 }p[];

 //最小费用最大流模板
 #define MAXN 120
 #define MAXM (2500*2+50)*2+100
 #define INF 0x3f3f3f3f
 using namespace std;
 struct Edge
 {
     int from, to, cap, flow, cost, next;
     Edge(int fr = , int tt = , int ca = , int fl = , int ct = , int nt = ) :from(fr), to(tt), cap(ca), flow(fl), cost(ct), next(nt)
     {
     };
 };
 Edge edge[MAXM];
 int Head[MAXN], edgenum;
 int pre[MAXN];//记录增广路径上 到达点i的边的编号
 int dist[MAXN];
 bool vis[MAXN];
 int N;//点数
 //int M;//边数
 int source, sink;//超级源点 超级汇点
 void init(int numnode,int st,int sk)
 {
     N = numnode, source = st, sink = sk;
     edgenum = ;
     memset(Head, -, sizeof(Head));
 }
 void addEdge(int u, int v, int w, int c)
 {
     //Edge E1 = { u, v, w, 0, c, head[u] };
     //edge[edgenum] = E1;
     edge[edgenum] = Edge(u, v, w, , c, Head[u]);
     Head[u] = edgenum++;
     //Edge E2 = { v, u, 0, 0, -c, head[v] };
     //edge[edgenum] = E2;
     edge[edgenum] = Edge(v, u, , , -c, Head[v]);
     Head[v] = edgenum++;
 }
 bool SPFA(int s, int t)//寻找花销最少的路径
 {
     //跑一遍SPFA 找s——t的最少花销路径 且该路径上每一条边不能满流
     //若存在 说明可以继续增广，反之不能
     queue<int> Q;
     memset(dist, INF, sizeof(dist));
     memset(vis, false, sizeof(vis));
     memset(pre, -, sizeof(pre));
     dist[s] = ;
     vis[s] = true;
     Q.push(s);
     while (!Q.empty())
     {
         int u = Q.front();
         Q.pop();
         vis[u] = false;
         for (int i = Head[u]; i != -; i = edge[i].next)
         {
             Edge E = edge[i];
             if (dist[E.to] > dist[u] + E.cost && E.cap > E.flow)//可以松弛 且 没有满流
             {
                 dist[E.to] = dist[u] + E.cost;
                 pre[E.to] = i;//记录前驱边 的编号
                 if (!vis[E.to])
                 {
                     vis[E.to] = true;
                     Q.push(E.to);
                 }
             }
         }
     }
     return pre[t] != -;//可达返回true
 }
 void MCMF(int s, int t, int &cost, int &flow)
 {
     flow = ;//总流量
     cost = ;//总费用
     while (SPFA(s, t))//每次寻找花销最小的路径
     {
         int Min = INF;
         //通过反向弧 在源点到汇点的最少花费路径 找最小增广流
         for (int i = pre[t]; i != -; i = pre[edge[i ^ ].to])
         {
             Edge E = edge[i];
             Min = min(Min, E.cap - E.flow);
         }
         //增广
         for (int i = pre[t]; i != -; i = pre[edge[i ^ ].to])
         {
             edge[i].flow += Min;
             edge[i ^ ].flow -= Min;
             cost += edge[i].cost * Min;//增广流的花销
         }
         flow += Min;//总流量累加
     }
 }

 int main()
 {
     int n,q;
     scanf("%d%d", &n, &q);
     for (int i = ; i <= n; i++) maxlv[i] = n, minlv[i] = ;
     bool flag = true;
     for (int i = ; i <= q; i++)
     {
         int type, li, ri, vi;
         scanf("%d%d%d%d", &type, &li, &ri, &vi);
         if (!flag)continue;
         if (type == )
         {
             for (int j = li; j <= ri; j++)
             {
                 if (minlv[j] < vi) minlv[j] = vi;
                 if (minlv[j] > maxlv[j])
                 {
                     flag = false;
                     break;
                 }
             }
         }
         else
         {
             for (int j = li; j <= ri; j++)
             {
                 if (maxlv[j] > vi) maxlv[j] = vi;
                 if (maxlv[j] < minlv[j])
                 {
                     flag = false;
                     break;
                 }
             }
         }
     }
     if (!flag) printf("-1\n");
     else
     {
         init( * n + , ,  * n + );
         for (int i = ; i <= n; i++)
         {
             addEdge(, i, , );
         }
         for (int i = ; i <= n; i++)
         {
             for (int j = minlv[i]; j <= maxlv[i]; j++)
             {
                 addEdge(i, n + j, , );
             }
         }
         for (int i = n + ; i <=  * n; i++)
         {
             for (int j = ; j <= n; j++)
             {
                 addEdge(i,  * n + , , j*j - (j - )*(j - ));
             }
         }
         int totflow = , totcost = ;
         MCMF(source, sink, totcost, totflow);
         //if (totcost < n) printf("-1\n");
         //else printf("%d\n", totcost);//之前flag判断是否可行也可用该步来替换
         printf("%d\n", totcost);
     }
     return ;
 }