第三周13/03/24

于 2013-07-17 00:27:14 发布
阅读量419 收藏
点赞数
分类专栏： 周赛 ACM暑假训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm18810549519/article/details/9348461
版权

为了巩固知识，先把把以前做的过但没做完的周赛重新做了一遍，重温知识。顺便记下一点


A. Circle Line

大水题，两个方向查找两点之间最短路 


#include <iostream>//A. Circle Line
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
int a[350];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    int s,t;
    scanf("%d%d",&s,&t);
    if(s>t)
    swap(s,t);
    int sum=0,mmin=0;
    for(int i=s;i<t;i++)
    sum+=a[i];
    for(int i=t;i<=n;i++)
    mmin+=a[i];
    for(int i=1;i<s;i++)
    mmin+=a[i];
    if(sum<mmin)
    mmin=sum;
    printf("%d\n",mmin);
    return 0;
}


B. New Problem

字符串问题，刚刚看题目，以为直接做会超时，后面发现其实只要搜带两位字符的字符串即可

思路：若a~z有一字符不存在则输出，否则把长度为两位的字符串放到给出的字符串里，若没有则输出


#include <iostream>//B. New Problem
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
string s[35];
int num[27]= {0};
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        cin>>s[i];
        int l=s[i].length();
        for(int j=0; j<l; j++)
        {
            num[s[i][j]-'a']++;
        }
    }
    for(int i=0; i<26; i++)
    {
        if(num[i]==0)
        {
            printf("%c\n",'a'+i);
            return 0;
        }

    }
    int flag;
    string ss;
    for(int i=0; i<26; i++)
    {
        for(int j=0; j<26; j++)
        {
            ss=(i+'a');
            ss+=(j+'a');
            flag=0;
            for(int k=0; k<n; k++)
            {
                if(s[k].find(ss) != -1)//找到了
                {
                    flag=1;
                    break;
                }
            }
            if(flag==0)
            {
                cout<<ss<<endl;
                return 0;
            }
        }
    }

    return 0;
}


C. Learning Languages

这个题目卡了我好久，看来并查集还是得好好理解

题意：给出n 个人以及他们会哪几种语言，学一种语言要花费1元（反正是一个单位，嘻嘻），但是只要A和B会同一种语言，那B会的其他语言，A学习不需要花费，相当于A也会了。
思路;把相同语言的人放一起组成一组，在对组内的人进行并查集

看代码吧： 

#include <iostream>//C. Learning Languages
#include <stdio.h>
#include <cstring>
#include <algorithm>//先把语言分组，对每种语言里的人进行并查集
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
int father[110];
int find(int x)
{
    while(x!=father[x])
    {
        x=find(father[x]);
    }
    return father[x];
}
void Union(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
    {
        father[fy]=fx;
    }
}
int lan[110][110];
int a[110]={0};
int main()
{
    int n,m,k,g,flag=0;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    father[i]=i;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&k);//k种语言
        if(k>0)//只要有一个人会一种语言就可以通过这个人去学那种语言
        flag=1;
        for(int j=1;j<=k;j++)
        {
            scanf("%d",&g);//语言
            lan[g][++a[g]]=i;//有哪些人
        }
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=2;j<=a[i];j++)
        {
            Union(lan[i][1],lan[i][j]);
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        if(father[i]==i)
        ans++;
    }
    if(flag==0)
    printf("%d\n",ans);
    else
    printf("%d\n",ans-1);

    return 0;
}


D. Set of Points

题意：n个点形成m边凸多边形，要求任意三点不成直线 special judge
不大懂得怎么做，看了别人代码，稍微有一点点懂，应该比较经典，记下再说 

#include <iostream>//D. Set of Points
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
const int M=100000;
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    if(m==3 && n>4)
    {
        printf("-1\n");
    }
    else
    {
        for(int i=0;i<m;i++)
        {
            printf("%d %d\n",i,i*i+M);
        }
        for(int i=0;i<n-m;i++)
        printf("%d %d\n",i,-i*i-M);
    }
    return 0;
}


E. Game

还没思路，懂了再说



F. Lights Out

其实这题还蛮简单的，只要认真读题，稍微思考就 很容易啦
题意：3*3的格子代表灯，初始值都为1代表亮，按下灯，亮变暗，暗变亮，并且被按下的灯的周围灯都会被改变，给出每一盏灯的的被按次数，求当前灯亮暗情况
思路：仔细分析可以发现，只要被按次数为偶数，那么状态不改变，反之则改变 

#include <iostream>//F. Lights Out
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
int a[10][10];
int b[10][10];
int dis[4][2]= {{0,1},{0,-1},{-1,0},{1,0}};
int main()
{
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            scanf("%d",&a[i][j]);
            b[i][j]=1;
        }

    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            if(a[i][j]%2==1)
            {
                if(b[i][j]==1)
                    b[i][j]=0;
                else
                    b[i][j]=1;
                for(int k=0; k<4; k++)
                {
                    int x=i+dis[k][0];
                    int y=j+dis[k][1];
                    if(x>=0 && x<3 && y>=0 && y<3)//三次runtime error，没考虑范围
                    {
                        if(b[x][y]==1)
                            b[x][y]=0;
                        else
                            b[x][y]=1;
                    }
                }
            }
        }
    }
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            printf("%d",b[i][j]);
        }
        printf("\n");
    }

    return 0;

}



G. Convex Shape


题意很简单，就不解释了~~

分析：1.X相同向Y方向走  2.Y相同向X方向走  3.先向X方向走，再向Y方向走  4.先向Y方向走，再向X方向走     中间只要有等于“W”的都不符合


#include <iostream>//G. Convex Shape
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
char aa[55][55];
int n,m;
struct node
{
    int x,y;
} num[5000];
int solve(node a,node b)
{
    if(a.x==b.x)
    {
        int m1=min(a.y,b.y);
        int m2=max(a.y,b.y);
        for(int i=m1+1; i<m2; i++)
        {
            if(aa[a.x][i]=='W')return 0;
        }
    }
    else if(a.y==b.y)
    {
        int m1=min(a.x,b.x);
        int m2=max(a.x,b.x);
        for(int i=m1+1; i<m2; i++)
        {
            if(aa[i][a.y]=='W')return 0;
        }
    }
    else
    {
        int f1=0,f2=0;
        if(a.x<b.x)
        {
            if(a.y<b.y)
            {
                for(int i=a.x; i<=b.x; i++)
                {
                    if(aa[i][a.y]=='W')f1=1;
                    if(aa[i][b.y]=='W')f2=1;
                }
                for(int i=a.y; i<=b.y; i++)
                {
                    if(aa[b.x][i]=='W')f1=1;
                    if(aa[a.x][i]=='W')f2=1;
                }
                if(f1&&f2)
                return 0;
            }
            else
            {
                for(int i=a.x; i<=b.x; i++)
                {
                    if(aa[i][a.y]=='W')f1=1;
                    if(aa[i][b.y]=='W')f2=1;
                }
                for(int i=b.y; i<=a.y; i++)
                {
                    if(aa[b.x][i]=='W')f1=1;
                    if(aa[a.x][i]=='W')f2=1;
                }
                if(f1&&f2)
                return 0;

            }
        }
        else
        {
            if(b.y<a.y)
            {
                for(int i=b.x; i<=a.x; i++)
                {
                    if(aa[i][a.y]=='W')f1=1;
                    if(aa[i][b.y]=='W')f2=1;
                }
                for(int i=b.y; i<=a.y; i++)
                {
                    if(aa[b.x][i]=='W')f1=1;
                    if(aa[a.x][i]=='W')f2=1;
                }
                if(f1&&f2)
                return 0;
            }
            else
            {
                for(int i=b.x; i<=a.x; i++)
                {
                    if(aa[i][a.y]=='W')f1=1;
                    if(aa[i][b.y]=='W')f2=1;
                }
                for(int i=a.y; i<=b.y; i++)
                {
                    if(aa[b.x][i]=='W')f1=1;
                    if(aa[a.x][i]=='W')f2=1;
                }
                if(f1&&f2)
                return 0;
            }
        }
    }
    return 1;
}
int main()
{
    int i,j,k=0;
    scanf("%d%d",&n,&m);
    for(i=0; i<n; i++)
    {
        scanf("%s",aa[i]);
        for(j=0; j<m; j++)
        {
            if(aa[i][j]=='B')
            {
                num[k].x=i;
                num[k].y=j;
                k++;
            }
        }
    }
    for(i=0; i<k; i++)
    {
        for(j=i+1; j<k; j++)
        {
            if(solve(num[i],num[j])==0)
            {
                printf("NO\n");
                return 0;
            }
        }
    }
    printf("YES\n");
    return 0;
}

PS：其实可以写的更短一点，只要把各种情况综合起来，我写多是为了要手动模拟一下的。。。。

简洁代码：

#include <iostream>//G另一简洁代码
using namespace std;
int n,m,x[3000],y[3000],k=0;
char s[50][50];
bool check(int x,int a1,int b1,int y,int a2,int b2)
{
    for(int i=min(a1,b1); i<=max(a1,b1); i++)
        if(s[x][i]=='W') return 0;
    for(int i=min(a2,b2); i<=max(a2,b2); i++)
        if(s[i][y]=='W') return 0;
    return 1;
}
int main()
{
    cin>>n>>m;
    for(int i=0; i<n; i++)
    {
        cin>>s[i];
        for(int j=0; j<m; j++)
            if(s[i][j]=='B') x[++k]=i,y[k]=j;
    }
    for(int i=1; i<k; i++)
        for(int j=i+1; j<=k; j++)
        {
            if(check(x[i],y[i],y[j],y[j],x[i],x[j])) continue;
            if(check(x[j],y[i],y[j],y[i],x[i],x[j])) continue;
            cout<<"NO";
            return 0;
        }
    cout<<"YES";
    return 0;
}



H. k-Multiple Free Set


题意还是很容易理解的，给你一组数，让你把他们拿出来，使得拿出来的数互相之间不能通过乘以K得到

刚开始先排序，然后直接搜索，只要拿到一个数，把它乘以K=S，若后面有与S相同的数就删除，但是乘起来的数据太大，我也不知道为什么总是RE，改了数组范围也不行。后面干脆不乘，相除，也不行。。。。

看了别人的代码，哇，太神了那个思想，用一个STL中的函数lower_bound，好使用

先大概了解一下lower_bound的用法：

函数介绍（百度来的）

lower_bound()返回一个 iterator 它指向在[first,last)标记的 有序序列中可以插入value，而不会破坏容器顺序的第一个位置，而这个位置标记了一个 大于等于value 的值。
例如，有如下序列：
ia[]={12,15,17,19,20,22,23,26,29,35,40,51};
用值21调用lower_bound(),返回一个指向22的iterator。用值22调用lower_bound(),也返回一个指向22的iterator。第一个版本使用底层的 < (小于)操作符，第二个版本根据comp进行排序和比较。

我的代码：

#include <iostream>//G. Convex Shape
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
int n,k;
long long int a[100010];
long long int v[100010];
bool vis[100010];
int main()
{
    memset(vis,0,sizeof(vis));
    scanf("%d%d",&n,&k);
    for(int i=0; i<n; i++)
        cin>>a[i];
    sort(a,a+n);
    int ans=0;
    for(int i=0; i<n; i++)
    {
        if(a[i]%k)v[ans++]=a[i];
        else
        {
            long long int g=a[i]/k;
            if(g!=*lower_bound(v,v+ans,g))
            v[ans++]=a[i];
        }
    }
    printf("%d\n",ans);
    return 0;
}


I. Zero Tree

看不太懂，慢慢理解咯，先贴大神的代码，自己后面再消化

/* 

一开始题目理解错误：“includes the vertex with number 1.”是指结点1而非其上integer为1的结点。
思路是先处理儿子再处理父亲。这是因为：设有结点x，x的val变为0所需操作次数x.count = in + de + r,这里in是x因为儿子结点的+1操作
而随之产生的+1操作的次数（对儿子的操作会传递到父亲），而de就是-1操作，显然，in是x的所有儿子中+1次数的最大值，de是所有儿子中-1次
数的最大值。而r是什么？在处理完儿子后确保儿子的val为0，但不保证x的val为0，r就是余下的对x操作的次数：r=x.val+in-de（这些操作是
发生在x和他的父亲之间的）。由以上于可见，对x.count的统计能转化为对其儿子结点的相关信息的统计，故而此前说“先处理儿子后处理父亲”。
结点1是最后处理的。
*/转的


#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <stdlib.h>
#include <queue>
using namespace std;
const int N=100010;
struct Total
{
    long long  in;
    long long  de;
}cnt[N];
vector<long long >node[N];
long long v[N];
bool vis[N];
Total dfs(int i)
{
    vis[i]=true;
    long long in=0,de=0;
    Total t;
    for(vector<long long >::iterator it=node[i].begin();it!=node[i].end();it++)
    {
        if(vis[*it])continue;
        t=dfs(*it);
        if(t.in>in)in=t.in;
        if(t.de>de)de=t.de;
    }
    cnt[i].de=de;
    cnt[i].in=in;
    int d=v[i]-cnt[i].de+cnt[i].in;
    if(d>0)
    cnt[i].de+=d;
    else
    cnt[i].in-=d;
    return cnt[i];
}
int main()
{
    int n,a,b;
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        cin>>a>>b;
        node[a].push_back(b);
        node[b].push_back(a);
    }
    for(int i = 1; i <= n; i++)
             scanf("%I64d", &v[i]);
        Total ans = dfs(1);
         printf("%I64d\n", ans.de + ans.in);
    return 0;
}



J. The Last Hole!

不懂这种题型，先放着


SeeYouAlways
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值