ACM-Codeforces Round #279 (Div. 2)

A. Team Olympiad

题意：

给你一行数据，它们的值是1、2、3中的一个，然后问可以构成同时包含1、2、3的组数有多少，并且输出每一组的信息，当然，是原数据的下标。

分析：

首先构造结构体，保存原数据值及其下标，然后使用三维动态数组，代表三种不同的值，将不同类型的结构体，放入对应的数组，最后循环扫描数组，输出信息，并弹出结构体，任何一项为空则停止操作。

源代码：

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;
struct node
{
    int value;
    int pos;
}nod;
vector<node> data[4];

int main()
{//freopen("sample.txt", "r", stdin);
    int n;
    while(~scanf("%d", &n))
    {
        for(int i=0; i<4; ++i)
            data[i].clear();
        for(int i=1; i<=n; ++i)
        {
            scanf("%d", &nod.value);
            nod.pos = i;
            // 将值映射为下标
            data[nod.value].push_back(nod);
        }
        int ans = 5005;
        for(int i=1; i<=3; ++i)
            ans = min(ans, (int)data[i].size());
        printf("%d\n", ans);
        int len1 = data[1].size();
        int len2 = data[2].size();
        int len3 = data[3].size();
        while(len1 && len2 && len3)
        {
            printf("%d ",  data[1][len1-1].pos);
            printf("%d ",  data[2][len2-1].pos);
            printf("%d\n", data[3][len3-1].pos);
            data[1].pop_back();
            data[2].pop_back();
            data[3].pop_back();
            --len1; --len2; --len3;
        }
    }
    return 0;
}

B. Queue

题意：

给出几行数据，每行两个数，代表某个数的前面是第一个数，后面是第二个数，特殊的当数据为零时代表某个数的前面或后面没有数，最后输出满足这些条件的数列。

分析：

其实本质还是模拟，先从0开始按给出的条件向后遍历，这样就可以得到排在偶数位的数，然后找一个还没有标记的数，向前遍历得到第1个数，然后继续按条件向后遍历，即可得到排在奇数位上的数。

源代码：

#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;
const int MAXN = 1000005;
int data1[MAXN], data2[MAXN];
int vis[MAXN], ans[MAXN];

int main()
{//freopen("sample.txt", "r", stdin);
    int n;
    while(~scanf("%d", &n))
    {
        memset(data1, -1, sizeof(data1));
        memset(data2, -1, sizeof(data2));
        memset(vis, 0, sizeof(vis));
        for(int i=1; i<=n; ++i)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            data1[a] = b;
            // data2主要是为了方便向前遍历
            data2[b] = a;
            vis[a]   = 1;
            vis[b]   = 1;
        }
        int tmp=0, k=2;
        // 找出偶数位上的数
        while(1)
        {
            ans[k] = data1[tmp];
            vis[ans[k]] = 0;
            k += 2;
            tmp = data1[tmp];
            if(tmp <= 0) break;
        }
        int found;
        for(int i=1; i<MAXN; ++i)
            if(vis[i])
                {found = i; break;}
        tmp = found;
        // 向前遍历找出第一位上的数
        while(1)
        {
            if(data2[tmp] < 0)
                break;
            tmp = data2[tmp];
        }
        k = 1;
        // 找出奇数位上的数
        while(1)
        {
            ans[k] = tmp;
            tmp = data1[tmp];
            k += 2;
            if(tmp <= 0) break;
        }
        for(int i=1; i<=n; ++i)
            i==n ? printf("%d\n",ans[i]):
                   printf("%d " ,ans[i]);
    }
    return 0;
}

C. Hacking Cypher

题意：

给一个很大的数s，然后给两个数a、b，现在让找出一种分割的方法，将s分成前后两部分，满足前一部分能被a整除，后一部分能被b整除。

分析：

方法似乎很明显了，就是枚举分割点，然后判断前一部分能否被a整除，后一部分能否被b整除。那么我们就先从前往后扫，记下能被a整除的位置，然后再从后往前扫，判断能被b整除的位置，同时判断该位置是否能被a整除。最后的问题就是如何判断一个大数能否被整除，下面给出两种方法的实现，可能在其它题目中也有用：

char num[1000010];
int a;

// 从前往后除
int solve1()
{
    int cur = 0;
    for(int i=0; i<strlen(num); ++i)
    {
        cur *= 10;
        cur += num[i]-'0';
        cur %= a;
    }
    if(!cur) return 1;
    return 0;
}

// 从后往前除
int solve2()
{
    int k = 1;
    int cur = 0;
    for(int i=strlen(num)-1; i>=0; --i)
    {
        cur += (num[i]-'0')*k;
        cur %= a;
        k *= 10;
        k %= a;
    }
    if(!cur) return 1;
    return 0;
}

源代码：

#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;
const int MAXN = 1000005;
char data[MAXN];
int  tage[MAXN];

int main()
{//freopen("sample.txt", "r", stdin);
    while(~scanf("%s", &data))
    {
        int a, b;
        memset(tage, 0, sizeof(MAXN));
        scanf("%d%d", &a, &b);
        int len = strlen(data);
        int cur = 0;
        // 判断前半部能被a整除的位置
        for(int i=0; i<len; ++i)
        {
            cur *= 10;
            cur += data[i]-'0';
            cur %= a;
            if(cur==0 && i<len-1 && data[i+1]!='0')
                tage[i] = 1;
        }
        int ok = 0;
        int k=1, pos;
        cur = 0;
        // 判断后半部能被b整除的位置
        for(int i=len-1; i>=0; --i)
        {
            cur += (data[i]-'0')*k;
            cur %= b;
            if(cur==0 && tage[i-1] && data[i]!='0')
            {
                ok  = 1;
                pos = i;
                break;
            }
            k *= 10;
            k %= b;
        }
        if(ok)
        {
            puts("YES");
            for(int i=0; i<pos; ++i)
                printf("%c", data[i]);
            puts("");
            for(int i=pos; i<len; ++i)
                printf("%c", data[i]);
            puts("");
        }
        else puts("NO");
    }
    return 0;
}