Codeforces Round #402 (Div. 2)

链接：http://codeforces.com/contest/779

 

A. Pupils Redistribution

题意：某中学有A、B两组学生，且每组都有n个人。每个学生的学术指数是已知的，是从1到5之间的某个正整数。A、B两组学生的学术指数分别是 a1, a2, ..., an 和

b1, b2, ..., bn。现在想在两组之间交换学生，问最少经过几次交换，可以使所有拥有同一个学术指数的两组学生数量相等，如果做不到，则输出-1。

分析：对于每一个学术指数Xi (1<=Xi<=5)，统计每组学生人数，作出两组数量之差再除以2得到 Di ，如果 ∑ Di = 0 说明可实现，( ∑ | Di | ) / 2 则是需交换的次数，如果

∑ Di ≠ 0，说明不可实现，输出 -1 即可。

代码：

#include<stdio.h>
#include<iostream>
using namespace std;

int cnt1[10], cnt2[10];

int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= 5; ++i)
            cnt1[i] = 0, cnt2[i] = 0;
        int x;
        for(int i = 0; i < n; ++i)
        {
            scanf("%d", &x);
            ++cnt1[x];
        }
        for(int i = 0; i < n; ++i)
        {
            scanf("%d", &x);
            ++cnt2[x];
        }

        bool sign = true;
        for(int i = 1; i <= 5; ++i)
        if((cnt1[i] - cnt2[i]) % 2)
        {
            sign = false;
            break;
        }
        if(!sign)
        {
            puts("-1");
            continue;
        }

//        for(int i = 1; i <= 5; ++i)
//            printf("%d %d\n", cnt1[i], cnt2[i]);//

        int flag = 0, ans = 0, temp;
        for(int i = 1; i <= 5; ++i)
        {
                temp = (cnt1[i] - cnt2[i]) / 2;
                flag += temp;
                if(temp > 0) ans += temp;
                else ans -= temp;
        }

        if(!flag) printf("%d\n", ans / 2);
        else puts("-1");
    }
    return 0;
}

/*
4
5 4 4 4
5 5 4 5

6
1 1 1 1 1 1
5 5 5 5 5 5

1
5
3

9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1

5
1 2 3 4 5
1 2 3 4 5
*/

 

B. Weird Rounding

题意：给你一个数 n 和数 k，你可以去掉数 n 中的一些位数，使它能被 10 ^ k 整除，问你最少去掉几位可以实现。（1. 题目保证有解 2. 规定前导零为不合法形式）

分析：从后面位数开始，遇到非零的位数直接去掉，直到最后连续的为零的位数达到 k 位为止，则此时已去掉的位数就是最少的。如果还未达到 k 位，数 n 的位数已经到头，

没有位数可去了，则说明前面这个策略失效，唯一的办法是将数 n 所有位数全部去掉，只保留一个 0。

代码：

#include<stdio.h>
using namespace std;

int dig[10];

int main()
{
    int n, k;
    while(~scanf("%d%d", &n, &k))
    {
        if(!n)
        {
            puts("0");
            continue;
        }

        int p = 0;
        while(n)
        {
            dig[p++] = n % 10;
            n /= 10;
        }

        int i, ans = 0, cnt = 0;
        for(i = 0; i < p && cnt < k; ++i)
        {
            if(dig[i]) ++ans;
            else ++cnt;
        }
        if(i == p && cnt < k)
        ans = p - 1;

        printf("%d\n", ans);
    }
    return 0;
}

/*
30020 3

100 9

10203049 2
*/

 

C. Dishonest Sellers

题意：某人去一个商店买东西，他总共需要买 n 件东西，已知这 n 件东西目前的价格分别是 a1, a2, ..., an。然而，商店一周后要降价促销，这 n 件东西的价格将变成 b1, b2, ..., bn。

然而，这个商店比较鸡贼，说是降价促销，其实某些商品反而是涨价的，也就是说，bi 不保证小于 ai (1 <= i <= n)。但是这个人比较心急，他必须现在就买至少 k 件东西，然后剩下

其余的东西可以等到一周后再买。问他要买这 k 件东西的最小花费。

分析：作出促销前后的价差 Di， 按从大到小排序，Di >= 0 表示现在买是赚的（或者是不赚不赔的），将来买是亏的（或者是不赚不赔的）；Di < 0 表示现在买是亏的，将来买是赚的。

如果 Di >= 0 的项（即非负项）多于或等于 k，那么现在可以把这些非负项都买走，反之，如果非负项少于 k，则不得不现在买走一些负项。既然这些 Di 是降序排列的，那么即使买走

一些负项，也是损失最小的方案。

代码：

#include<stdio.h>
#include<algorithm>
using namespace std;

struct item
{
    int a, b, d;
} t[220000];

bool cmp(item x, item y)
{
    return x.d > y.d;
}

int main()
{
    int n, k;
    while(~scanf("%d%d", &n, &k))
    {
        for(int i = 0; i < n; ++i)
            scanf("%d", &t[i].a);
        for(int i = 0; i < n; ++i)
            scanf("%d", &t[i].b);
        for(int i = 0; i < n; ++i)
            t[i].d = t[i].b - t[i].a;
        sort(t, t + n, cmp);

        int p = 0, ans = 0;
        while(t[p].d >= 0 && p < n) ++p;
        if(p < k)
        {
        for(int i = 0; i < k; ++i)
            ans += t[i].a;
        for(int i = k; i < n; ++i)
            ans += t[i].b;
        }
        else
        {
        for(int i = 0; i < p; ++i)
            ans += t[i].a;
        for(int i = p; i < n; ++i)
            ans += t[i].b;
        }

        printf("%d\n", ans);
    }
    return 0;
}

/*
3 1
5 4 6
3 1 5

5 3
3 4 7 10 3
4 5 5 12 5

1 1
1
1

1 0
1
1
*/

 

D. String Game

题意：给你一个长串 t 和一个短串 p， 给定一个下标序列，你必须按照这个序列依次删除 t 中的对应下标的字符，直至串 t 为空串（删除过程中，下标标号不变）。问在保证串 p 是串 t

的子序列的情况下，最多可以删除多少个字符？

分析：注意到如果多删除字符的 t 是 p 的母串，那么少删除字符的 t 一定能保证是 p 的母串。因此可以对删除序列进行二分，找到恰好使 t 变成非母串的删除字符的位置。注意，二分完

成时，需要对 mid 所在的位置进行讨论，因为 mid 既可能是最后一个 t 为母串的位置，也可能是第一个 t 为非母串的位置。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;

const int N = 220000;
int a[N];
int next[N], S[N], T[N];
bool sig[N];
char t[N], t1[N], p[N];
int c[N], d[N];
vector<int> location[30];

bool Find(char* a, int l1, char* b, int l2)
{
    int i = 0, j = 0;
    bool sign = true;
     while(j < l2)
     {
         if(!sign) break;
        while(a[i] != b[j])
        {
            ++i;
            if(i >= l1)
            {
                sign = false;
                break;
            }
        }

        ++i, ++j;
    }

    return sign;
    //return !(i >= l1 && j < l2);
}

int main()
{
    while(~scanf("%s%s", t, p))
    {
        int l1 = strlen(t);
        int l2 = strlen(p);
        for(int i = 0; i < l1; ++i)
        {
            scanf("%d", &a[i]);
            a[i] -= 1;
        }

        int l = 0, r = l1 - 1, mid;
        bool flag;
        while(l <= r)
        {
            mid = l + r >> 1;
            memset(sig, false, sizeof sig);
            for(int i = 0; i <= mid; ++i)
                sig[a[i]] = true;

            int k = 0;
            for(int i = 0; i < l1; ++i)
                if(!sig[i])
                t1[k++] = t[i];
            t1[k] = '\0';
            //printf("%d %s\n", mid, t1);//

            flag = Find(t1, k, p, l2);
            if(flag) l = mid + 1;
            else r = mid - 1;
        }
        printf("%d\n", flag? mid + 1: mid);
    }
    return 0;
}

/*
ababcba
abb
5 3 4 1 7 6 2
3

bbbabb
bb
1 6 3 4 2 5
4

aa
a
1 2
1

ab
a
1 2
0

ab
a
2 1
1
*/

 

E. Bitwise Formula

题意：给你一个数 n，一个数 m，然后 n 行，每行定义一个变量，有的变量直接被赋值为一个 m 位的二进制数，有的变量由前面的变量或者用 ”？“ 经过AND，OR，XOR三种位运算得出。

现在要你给变量 ”？“ 赋值（只能是 m 位二进制数），使这 n 个变量的和最大或最小，并输出相应的这个 m 位二进制数。

分析：注意到对于所有变量，其每一个二进制位的运算是相互独立的，因此对于每一位，对每个变量而言，如果能得出尽可能多的 ”1“ ，则这一位相加的和是最大的，反之，得出尽可能少

的 ”1“ ，则这一位相加的和是最小的。

代码：

#include<stdio.h>
#include<string>
#include<map>
#include<algorithm>
#include<iostream>
using namespace std;

const int N = 5500;
const int M = 1100;

string s1, s2, s3;
int val[N];
int n, m, top;
int ans1[M], ans2[M];
map<string, int> ID;
int idcnt;

struct data
{
    int x, y, z;
    string w, op;
    int t;
} a[N];

//bool isdigit(char ch)
//{
//    return ('0' <= ch && ch <= '9');
//}

int code(string s)
{
    if(s == "?") return 0;
    if(!ID.count(s)) ID[s] = ++idcnt;
    return ID[s];
}

int work(int bit, int x)
{
    int res = 0;
    val[0] = x;
    for(int i = 0; i < n; ++i)
    {
        int k = a[i].x;
        if(a[i].t == 0)
        {
            val[k] = a[i].w[bit] - '0';
        }
        else
        {
            switch(a[i].op[0])
            {
            case 'A':
                val[k] = val[a[i].y] & val[a[i].z];
                break;
            case 'O':
                val[k] = val[a[i].y] | val[a[i].z];
                break;
            case 'X':
                val[k] = val[a[i].y] ^ val[a[i].z];
                break;
            }
        }
        res += val[k];
    }
    return res;
}

int main()
{
    while(cin >> n >> m)
    {
        for(int i = 0; i < n; ++i)
        {
            cin >> s1 >> s2;
            a[i].x = code(s1);
            cin >> s1;
            if(isdigit(s1[0]))
            {
                a[i].t = 0;
                a[i].w = s1;
                continue;
            }
            cin >> s2 >> s3;
            a[i].y = code(s1), a[i].op = s2;
            a[i].z = code(s3), a[i].t = 1;
        }

        for(int i = 0; i < m; ++i)
        {
            int t1 = work(i, 0), t2 = work(i, 1);
            if(t1 < t2) ans1[i] = 0, ans2[i] = 1;
            else if(t1 > t2) ans1[i] = 1, ans2[i] = 0;
            else ans1[i] = ans2[i] = 0;
        }

        for(int i = 0; i < m; ++i) cout << ans1[i];
        cout << endl;
        for(int i = 0; i < m; ++i) cout << ans2[i];
        cout << endl;
    }
    return 0;
}

/*
3 3
a := 101
b := 011
c := ? XOR b

5 1
a := 1
bb := 0
cx := ? OR a
d := ? XOR ?
e := d AND bb
*/