Question

这是问题here的链接我们必须告知必须放置字母（如砖块）的顺序，以使墙稳定。即例如，如果输入是

ZOAAMM
ZOAOMM
ZOOMOM
ZZZZOM

然后，如果我先放置“ A”，那么它们将倒在地上，因为要放置字母“ A”，我需要先放置字母“ Z”和“ O”。如果我先放置所有O，那么它们也会落在地上，因为某些O依赖于首先放置下面的“ Z”。

上面的答案是“ ZOMA”或“ ZOAM”都是有效答案。如果不可能，则应打印-1。我在代码中所做的是首先创建了一个图形。对于上面的示例，图形将为O-> A，因为A依赖于O。O-> M，因为M也依赖于O。Z-> O，因为O依赖于Z。
然后，如果图形中存在一个循环，则意味着无法铺设墙，所以我打印-1 如果没有周期，则答案存在，要得到答案，我会进行拓扑排序。

所有示例测试用例都通过了，但是当我提交时，我得到了错误的答案。我不知道哪个测试用例可能失败。您能告诉我我的代码失败的任何情况吗？

#include<bits/stdc++.h>
using namespace std;
vector<int>adj[26]; // adjacency list to store the graph
int n,m;        // n rows each with a string of size m
string s[30];
bool vis[26];   //for topological sort
int visited[26];//for cycle detection
stack <char> mystack;
bool flag = 0;
void cycledfs(int node) // returns -1 if cycle detected
{
  if(visited[node] == -1)
  {
      flag = 1;
      return;
  }

  visited[node] = -1;

  for(int i = 0; i < adj[node].size(); i++)
  {
      if(visited[adj[node][i]] != 1)
      {
          cycledfs(adj[node][i]);
      }
  }
  visited[node] = 1;
}
void dfs(int node)  // if cycle is not detected we do the topological sorting
{
    
    if(!vis[node])
    {
        vis[node] = 1;
        for(int i = 0; i < adj[node].size(); i++)
        {
            if(!vis[adj[node][i]])
                dfs(adj[node][i]);

        }
        mystack.push(node+'A');
    }
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        set <char> t; // set to store all the unique letters which are my vertices of the graph
        for(int i = 0; i <n; i++)
        {
            cin>>s[i];
            for(int j = 0; s[i][j]!='\0';j++)
                t.insert(s[i][j]);

            if(i)
            {
                for(int j = 0; s[i][j]!='\0';j++)//to check if the brick above me is different from me. Also making sure no duplicates in the graph.
                {
                    auto it = find(adj[s[i][j]-'A'].begin(), adj[s[i][j]-'A'].end(), (s[i-1][j]-'A'));
                    if(((s[i][j]-'A') != (s[i-1][j]-'A')) &&(it==adj[s[i][j]-'A'].end()))
                        adj[s[i][j]-'A'].push_back((s[i-1][j]-'A'));
                }

            }
        }
        //initializing stuff
        flag = 0;
        memset(visited, 0, sizeof(visited));
        memset(vis, 0, sizeof(vis));
         
        for(char i: t)//CYCLE CHECKING
        {
          //cout<<(i-'A')<<"\n";
          if(visited[i-'A'] == 0)
               cycledfs(i-'A');
          if(flag)
            break;
        }
        if(flag)
            cout<<"-1\n";
       
        else  //doing topological sort if no cycle
        {
            string result ="";
            for(char x: t)
                dfs(x-'A');
            while(!mystack.empty())
            {
                char ans = mystack.top();
                result.push_back(ans);
                mystack.pop();
            }
            cout<<result<<"\n";

        }
        for(int i = 0; i < 26; i++) //clearing adj list
                adj[i].clear();
    }

}

Google Kickstart C轮：稳定墙，错误答案

0 个答案: