20130902组队赛Regionals 2012, Latin America

最新推荐文章于 2024-05-26 12:48:31 发布

原创最新推荐文章于 2024-05-26 12:48:31 发布 · 916 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Regionals 2012 #Latin America

组队赛专栏收录该内容

14 篇文章

订阅专栏

本文精选了几道算法竞赛题目并提供了详细的解决方案，包括字典树、线段树等数据结构的应用，以及暴力枚举、递归搜索等算法技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C. Cellphone Typing

字典树，还得学，不过我自己写的这个不知道为什么总是一输入字符串就挂了，不知道为啥呀。结构体的string怎么都

不能被赋值，好奇怪.

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <functional>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cassert>
#include <bitset>
#include <stack>
#include <ctime>
#include <list>
#define INF 0x7fffffff
#define max3(a,b,c) (max(a,b)>c?max(a,b):c)
#define min3(a,b,c) (min(a,b)<c?min(a,b):c)
#define mem(a,b) memset(a,b,sizeof(a))

using namespace std;
struct node
{
    string app;
    int sum;
} num[100005];
int n;
int vis[100005];
bool cmp(node a, node b)
{
    return a.app < b.app;
}
int main()
{
    while(scanf("%d", &n) == 1)
    {
        mem(num, 0);
        mem(vis, 0);
        int MAX = -INF;
        string ko;
        for(int i = 0; i < n; ++i)
        {
            cout << i << endl;
            cin >> ko;
            int len = ko.length();
            if(len > MAX)
                MAX = len;
            num[i].app = ko;
            num[i].sum = 0;
        }
        sort(num, num+n, cmp);
        //int st = 0;
        if(num[0].app[0] != num[1].app[0])
        {
            num[0].sum++;
            vis[0] = 1;
        }
        for(int st = 0; st < MAX; st++)
        {
            for(int i = 0; i < n; ++i)
            {
                if(!vis[i])
                {
                    if(i == 0)
                    {
                        if(num[i].app[st] != num[i+1].app[st])
                        {
                            num[i].sum ++;
                            vis[i] = 1;
                        }
                    }
                    else
                    {
                        if(num[i].app[st] != num[i+1].app[st] && num[i].app[st] != num[i-1].app[st])
                        {
                            num[i].sum ++;
                            vis[i] = 1;
                        }
                    }
                }
            }
        }
        double ans = 0;
        for(int i = 0; i < n; ++i)
            ans += num[i].sum;
        ans = ans/n;
        printf("%.2lf\n", ans);
    }
    return 0;
}

D. Different Digits

暴搞的题目，刚开始就看到这道题目了，蛮短的，题目意思就是给你一个区间然后判断在这个区间上拥有每一位都是

不同数字的数字有多少个？暴力枚举判断即可：

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <functional>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cassert>
#include <bitset>
#include <stack>
#include <ctime>
#include <list>
#define INF 0x7fffffff
#define max3(a,b,c) (max(a,b)>c?max(a,b):c)
#define min3(a,b,c) (min(a,b)<c?min(a,b):c)
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int n, m;
int num[6000];
int vis[10];
void init()
{
    for(int i = 1; i < 10; ++i)
        num[i] = i;
    int flag = 0;
    for(int i = 10; i <= 5000; ++i)
    {
        flag = 0;
        mem(vis, 0);
        int tt = i;
        while(tt!=0)
        {
            int tp = tt%10;
            if(vis[tp])
            {
                flag = 1;
                break;
            }
            vis[tp] = 1;
            tt /= 10;
        }
        if(!flag)
            num[i] = num[i-1] + 1;
        else
            num[i] = num[i-1];
        //cout << num[i] << endl;
    }
}
int main()
{
    init();
    while(scanf("%d%d",&n, &m) == 2)
    {
        printf("%d\n", num[m] - num[n-1]);
    }
    return 0;
}

G. Game of Tiles

这道题目的意思就是两个人面对一个棋盘上面有白格有黑格，白格上面可以写数字，然后当一个人写下一个数字的时

候，另外一个人必须在这个格子的上下左右四个方向上寻找一个白色格子写下数字。直到有一个人不能写数字那么这

个人就输了。我是倒推的，对于一个点如果它的四个方向上的路径中至少有一条是奇数的，那么位于这个点的人必

败，因为下一个人一定会选择奇数的路径，这样当前点就输了。就这样一直倒推到起点，如果对于所有可能的起点，

我们至少能够找到一个点可以必胜，那么先手就赢。如果都没有的话，那么就必输。按照这样的思路，把所有能够想

到的情况都过了，可是还是WA，不知道有什么特殊的样例呢。

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
#define maxn 1000
char mp[maxn][maxn];
int n, m;
int vis[maxn][maxn];
int now[maxn][maxn];
int num[maxn][maxn];
int dir[4][2] = {{-1, 0},{0, 1},{1, 0},{0, -1}};
int ans = 0;
bool inmap(int x, int y)
{
    if(x < 0 || x >= n || y < 0 || y >=m)
        return false;
    return true;
}
void DFS(int x, int y)
{
    num[x][y] ++;
    vis[x][y] = 1;
    int flag = 0;
    for(int i = 0; i < 4; ++i)
    {
        int xx = x+dir[i][0];
        int yy = y+dir[i][1];
        if(!vis[xx][yy] && inmap(xx, yy) && mp[xx][yy] == '.')
        {
            DFS(xx, yy);
            if(num[xx][yy] % 2 == 1)
            {
                flag = 1;
                break;
            }
        }
    }
    if(flag == 1)
        num[x][y] ++;
}
int main()
{
    while(scanf("%d%d", &n, &m) == 2)
    {
        mem(mp, 0);
        mem(now, 0);
        mem(num, 0);
        for(int i = 0; i < n; ++i)
            scanf("%s", mp[i]);
        int fp = 0;
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(mp[i][j] == '.')
                {
                    mem(vis, 0);
                    mem(num, 0);
                    DFS(i, j);
                    if(num[i][j] % 2 == 1)
                    {
                        fp = 1;
                        printf("1\n");
                        i = n;
                        break;
                    }
                }
            }
        }
        if(!fp)
            printf("2\n");
    }
    return 0;
}

H：Hours and Minutes

这道题目直接写吧：

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <functional>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cassert>
#include <bitset>
#include <stack>
#include <ctime>
#include <list>
#define INF 0x7fffffff
#define max3(a,b,c) (max(a,b)>c?max(a,b):c)
#define min3(a,b,c) (min(a,b)<c?min(a,b):c)
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int n;
int main()
{
    while(scanf("%d", &n) == 1)
    {
        if(n%6 == 0)
        printf("Y\n");
        else
        printf("N\n");
    }
    return 0;
}

I. Interval Product

线段树，感觉到数据结构的强大，每次都会有线段树或者树状数组。题目意思就是有两种操作C 改变某个值。P计算

某一区间上的数字的乘积的正负。一般的比超，还是数据结构

#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <map>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <functional>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cassert>
#include <bitset>
#include <stack>
#include <ctime>
#include <list>
#define INF 0x7fffffff
#define max3(a,b,c) (max(a,b)>c?max(a,b):c)
#define min3(a,b,c) (min(a,b)<c?min(a,b):c)
#define mem(a,b) memset(a,b,sizeof(a))

using namespace std;
struct node
{
    int l, r;
    int fuhao;
} num[500010];
int n, m;
int ans;
int st, ed;
int cnt[100010];
int tp;
char str[5];
void build(int le, int ri, int inde)
{
    num[inde].l = le;
    num[inde].r = ri;
    if(le == ri)
        num[inde].fuhao = cnt[le];
    else
    {
        int mid = (le+ri)/2;
        build(le, mid, inde*2);
        build(mid+1, ri, inde*2+1);
        num[inde].fuhao =num[inde*2].fuhao*num[2*inde+1].fuhao;
    }
}
void update(int le, int val, int inde)
{
    if(num[inde].l == le &&num[inde].r == le)
        num[inde].fuhao = val;
    else
    {
        int mid = (num[inde].l +num[inde].r)/2;
        if(le <= mid)
            update(le, val, inde*2);
        else update(le, val, inde*2+1);
        num[inde].fuhao =num[inde*2].fuhao*num[2*inde+1].fuhao;
    }
}
void query(int le, int ri, int inde)
{
    if(num[inde].l == le &&num[inde].r == ri)
        ans *=num[inde].fuhao;
    else
    {
        int mid = (num[inde].l +num[inde].r)/2;
        if(ri <= mid)
            query(le, ri, inde*2);
        else if(le > mid)
            query(le, ri, inde*2+1);
        else
        {
            query(le, mid, 2*inde);
            query(mid+1, ri, 2*inde+1);
        }
    }
}
int main()
{
    while(scanf("%d%d", &n, &m) == 2)
    {
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d", &tp);
            if(tp > 0)
                cnt[i] = 1;
            else if(tp < 0)
                cnt[i] = -1;
            else
                cnt[i] = 0;
        }
        build(1, n, 1);
        for(int i = 0; i < m; ++i)
        {
            scanf("%s", str);
            if(str[0] =='C')
            {
                scanf("%d%d", &st, &ed);
                if(ed > 0)
                    ed = 1;
                else if(ed < 0)
                    ed = -1;
                else
                    ed = 0;
                update(st, ed, 1);
            }
            else
            {
                scanf("%d%d", &st, &ed);
                ans = 1;
                query(st, ed, 1);
                if(ans > 0)
                    printf("+");
                else if(ans < 0)
                    printf("-");
                else
                    printf("0");
            }
        }
        printf("\n");
    }
    return 0;
}