Codeforces Round #290 (Div. 2) B题 C题

 详细：view

B题：

 题意：给定N*M的矩阵，判断是否有环，要求环上的每一个格子颜色相同，且至少有4个格子。

 思路：转化为无向图中是否有环的问题。如果对于一个连通图，没有环的话，那么则形成一棵树，设树上顶点数为V，

            总的边数为sum(每个点的度数之和的一半)，则v-sum=1，可由此判断连通图是否有环。对于非连通图，dfs就可以解决了。

 代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<cmath>
#include<map>
#include<set>
#define SD second
#define FT first
#define sf scanf
#define pf printf
using namespace std;
typedef long long LL;
typedef pair<int ,int> P;
bool vis[55][55];
char g[55][55];
int n,dx[4]={-1,1,0,0};
int m,dy[4]={0,0,-1,1};
int sum,v;
int cal(P st,char ch)
{
         int ans=0;
         for(int k=0;k<4;k++){
                  int i,j;
                  i=st.FT+dx[k],j=st.SD+dy[k];
                  if(i>=0&&i<n&&j>=0&&j<m&&g[i][j]==ch)  ans++;
         }
         return ans;
}
void dfs(int i,int j,char ch)
{
         vis[i][j]=1;
         v++,sum+=cal(make_pair(i,j),ch);
         for(int k=0;k<4;k++){
                  int x,y;
                  x=i+dx[k],y=j+dy[k];
                  if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==ch&&!vis[x][y])
                           dfs(x,y,ch);
         }
}
int main()
{
         sf("%d%d",&n,&m);
         for(int i=0;i<n;i++)
                  sf("%s",g[i]);
         bool ok=0;
         for(int k=0;k<26;k++)
         {
                  char ch='A'+k;
                  memset(vis,0,sizeof(vis));
                  for(int i=0;i<n;i++){
                           for(int j=0;j<m;j++)
                           if(g[i][j]==ch&&!vis[i][j]){
                                    sum=0,v=0;
                                    dfs(i,j,ch);
                                    if((v-(sum/2))==1||v==0) continue;
                                    else {
                                             ok=1;
                                             break;
                                    }
                           }
                           if(ok) break;
                  }
         }
         if(ok) puts("Yes");
         else puts("No");
         return 0;
}

 C题：

 题意：给定一组字符串序列，求一组a-z合法的排列使得给定的序列是以由小到大的字母序排列的。

 思路：简单的top排序题，关键就是建图，把一个字母当做一个节点，题目还是很简单的，感觉B，C题没多大难度差别！

 代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<cmath>
#include<map>
#include<queue>
#define SD second
#define FT first
#define sf scanf
#define pf printf
using namespace std;
typedef long long LL;
typedef pair<int ,int> P;
char ss[105][105];
int indu[30];
vector<int> ans,G[30];
int get(char s1[],char s2[])
{
         int pos=-1,len=min(strlen(s1),strlen(s2));
         for(int i=0;i<len;i++)
                  if(s1[i]!=s2[i]) {
                           pos=i;
                           break;
                  }
         return pos;
}
void topsort()
{
         int u;queue<int> q;
         for(int i=0;i<26;i++)
                  if(indu[i]==0) ans.push_back(i),q.push(i);
         while(!q.empty()){
                  int v=q.front();q.pop();
                  for(int i=0;i<G[v].size();i++)
                  {
                           u=G[v][i];indu[u]--;
                           if(indu[u]==0){
                                    ans.push_back(u);
                                    q.push(u);
                           }
                  }
         }
        if(ans.size()!=26) puts("Impossible");
        else{
             for(int i=0;i<26;i++)
                  pf("%c",ans[i]+'a');
        }
}
int main()
{
         memset(indu,0,sizeof(indu));
         for(int i=0;i<30;i++)
                  G[i].clear();
         ans.clear();
         int n;sf("%d",&n);
         for(int i=0;i<n;i++){
                  sf("%s",ss[i]);
         }
         bool ok=1;
         for(int i=0;i<n-1;i++){
                  int pos=get(ss[i],ss[i+1]);
                  if(pos==-1){
                           if(strlen(ss[i])>strlen(ss[i+1])) {
                                             ok=0;
                                             break;
                           }
                           else continue;
                  }
                  else{
                           indu[ss[i+1][pos]-'a']++;
                           G[ss[i][pos]-'a'].push_back(ss[i+1][pos]-'a');
                  }
         }
         if(!ok) puts("Impossible");
         else {
                  topsort();
         }
         return 0;
}