Codeforces Round #575 (Div. 3)

链接：http://codeforces.com/contest/1196
来源：Codeforces

C. Robot Breakout(思维)

  题意：给你n个机器人，输入他们的位置和能够走的方向，问是否存在一个点使得所有的机器人都可以到达。
  思路：我们记录所有机器人能够向四个方向走到的极限位置；
  min_x：所有机器人能够向左移动的最小的x；
  max_x：所有机器人能够向右移动的最大的x；
  max_y：所有机器人能够向上移动的最大的y；
  min_y：所有机器人能够向下移动的最小的y；
  如果所有的机器人的向下移动的最小y小于等于向上移动的最大的y，说明所有的机器人都可以沿着y轴在这之间移动，同理，如果向左移动的最小的x小于等于向右移动的最大的x，机器人可以沿着x轴在这之间移动。最终输出最远能够到达的点即可。

#include
using namespace std;

const int inf=100000;

int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		int n,min_x=-inf,max_y=inf,max_x=inf,min_y=-inf;
		scanf("%d",&n);
		while(n--){
			int x,y,f1,f2,f3,f4;
			scanf("%d%d%d%d%d%d",&x,&y,&f1,&f2,&f3,&f4);
			if(!f1) min_x=max(min_x,x);
			if(!f2) max_y=min(max_y,y);
			if(!f3) max_x=min(max_x,x);
			if(!f4) min_y=max(min_y,y);
		}
		if(min_x<=max_x&&min_y<=max_y) printf("1 %d %d\n",max_x,max_y);
		else printf("0\n");
	}
	return 0;
}

D. RGB Substring(思维+前缀和)

  题意：给你一个字符串s=“RGBRGBRGB…”，输入字符串长度和一个k，接着输入一个字符串，题目要求我们找到一个长度为k的串使它是字符串s的子串，如果把这个长度为k的串变成s的子串我们最少需要修改多少个字符。
  思路：我们有三种情况来对比给出的字符串有多少个是匹配的。以示例举例：
  BGGGG    BGGGG    BGGGG
  RGBRG    GBRGB    BRGBR
  10110     11101    01011
  每次匹配只有这三种情况(分别以’R’, ‘G’, 'B’开头)，我们假设一个字符如果不需要修改(上下两个字符相同)我们就把他的贡献记为0，否则记为1。记下每一种情况的前缀和，随和我们就可以知道最少的修改次数。

#include
using namespace std;

typedef long long ll;
const int inf=0x3f3f3f3f;
const int Max_n=2e5+10;
char a[Max_n];
int sum[3][Max_n];//三种情况下,长度为j时的贡献度

int main(){
	int T;
	scanf("%d",&T);
	while(T--){
        int n,k;
        scanf("%d%d",&n,&k);
        scanf("%s",a+1);
        sum[0][0]=sum[1][0]=sum[2][0]=0;
        int b[3]={'R','G','B'};
        for(int i=0;i<3;i++){
            for(int j=1;j<=n;j++){
                if(a[j]!=b[(i+j-1)%3]) sum[i][j]=sum[i][j-1]+1;//不相等贡献为一
                else sum[i][j]=sum[i][j-1];//否则贡献为零
            }
        }

        /**for(int i=0;i<3;i++){
            for(int j=1;j<=n;j++){
                printf("%d ",sum[i][j]);
            }
            printf("\n");
        }*/

        int ans=inf;
        for(int i=0;i<3;i++){
            for(int j=0;j+k<=n;j++){
                ans=min(ans,sum[i][j+k]-sum[i][j]);
            }
        }
        printf("%d\n",ans);
	}
	return 0;
}

E. Connected Component on a Chessboard(思维)

  题意：有一个棋盘，类似于国际象棋的棋盘(黑白交替)——白色的上下左右可以是黑色，反之亦然，(1,1)处是黑色，现在给你黑棋和白棋的数量，问这些棋子是否可以构成一个连通块，如果可以请你输入它们的位置。
  思路：我们现在假设白棋的数量较少(黑色同理)，可以很容易发现，无论给多少的棋子，在一行都可以放下全部的棋子，我们先把白棋放在棋盘上(从2,2开始放)(如果是黑棋少就从3,2开始放)，然后这一行可以放下全部的棋子，那么白棋的旁边可以放同等的黑棋，放下以后再判断白棋的下方和上方还能放多少个，输出即可。放不下的情况就是3*w+1>b —— 第一个白棋周围可以有四个黑棋，剩下的白棋周围只可以有三个黑棋。

#include
using namespace std;
 
typedef long long ll;
const int inf=0x3f3f3f3f;
const int Max_n=2e5+10;
 
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		int b,w,s=2;//先放少的(我们假设白的少)
		scanf("%d%d",&b,&w);
		if(b<w) swap(b,w),s=3;//黑块少,先放黑色
		if(b>3*w+1) printf("NO\n");
		else{
			printf("YES\n");
			for(int i=1;i<=w;i++)
				printf("%d %d\n",s,2*i);
			for(int i=1;i<=w;i++,b--)
				printf("%d %d\n",s,2*i-1);
			for(int i=1;i<=w&&b>0;i++,b--)
				printf("%d %d\n",s-1,2*i);
			for(int i=1;i<=w&&b>0;i++,b--)
				printf("%d %d\n",s+1,2*i);
			if(b) printf("%d %d\n",s,2*w+1);
		}
 
	}
    return 0;
}

F. K-th Path(Floyd)

  题意：给我们一个图，找图中任意两点间第k短路。
  思路：我们先选出min(m,k)条边，第k小的数一定在这个之中产生，我们把这k条边建成一个图，用floyd求出任意两点间的距离，找到第k小的数即可。

#include
using namespace std;

typedef long long ll;
const int inf=0x3f3f3f3f;
const int Max_n=2e5+10;
int pos[Max_n];
ll dp[810][810],ans[640010];
bool vis[Max_n];

struct Edge{
	int u,v;
	ll w;
	bool operator <(const Edge &a)const {
		return w<a.w;
	}
}edge[Max_n];

vector<int>v;

int main(){
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	memset(dp,0x3f,sizeof(dp));
	for(int i=1;i<=m;i++)
		scanf("%d%d%lld",&edge[i].u,&edge[i].v,&edge[i].w);
	sort(edge+1,edge+m+1);
	for(int i=1;i<=min(m,k);i++){//键图
		if(!vis[edge[i].v]){
			v.push_back(edge[i].v);
			vis[edge[i].v]=1;
			pos[edge[i].v]=v.size();
		}
		if(!vis[edge[i].u]){
			v.push_back(edge[i].u);
			vis[edge[i].u]=1;
			pos[edge[i].u]=v.size();
		}
		dp[pos[edge[i].u]][pos[edge[i].v]]=dp[pos[edge[i].v]][pos[edge[i].u]]=edge[i].w;
		///printf("***** $%d $%d\n",pos[edge[i].u],pos[edge[i].v]);
		///printf("*******%d %d %lld %d %d\n",edge[i].u,edge[i].v,edge[i].w,pos[edge[i].u],pos[edge[i].v]);
	}
	int V=v.size();
	/**for(int i=1;i<=V;i++){
        for(int j=1;j<=V;j++)
            printf("%lld ",dp[i][j]);
        printf("\n");
	}*/
	for(int i=1;i<=V;i++)
		for(int j=1;j<=V;j++)
			if(i==j) dp[i][j]=0;
	for(int k=1;k<=V;k++)
		for(int i=1;i<=V;i++)
            for(int j=1;j<=V;j++)
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);

    /**printf("==========================\n");
    for(int i=1;i<=V;i++){
        for(int j=1;j<=V;j++)
            printf("%lld ",dp[i][j]);
        printf("\n");
    }*/
	int cnt=0;
	for(int i=1;i<=V;i++)//注意这里只取上三角或者下三角
		for(int j=i+1;j<=V;j++)
			if(dp[i][j]&&dp[i][j]!=inf)
                ans[++cnt]=dp[i][j];
	sort(ans+1,ans+cnt+1);
	printf("%lld\n",ans[k]);
    return 0;
}