代码求调

#include <bits/stdc++.h>
#define INF 0x7fffffff
#define MAXN 100005
using namespace std;

string str[205]; 

struct Dinic
{
    int s, t;

    struct Edge
    {
        int to, next, w;
    } edges[MAXN];

    int _count = 1, head[MAXN], cur[MAXN];

    void add(int u, int v, int w)
    {
        edges[++_count].next = head[u];
        edges[_count].to = v;
        edges[_count].w = w;
        head[u] = _count;
    }

    int level[MAXN];

    bool bfs()
    {
        memset(level, 0, sizeof(level));
        memcpy(cur, head, sizeof(head));
        queue<int> q;
        q.push(s);
        level[s] = 1;
        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            for (int i = head[u]; i != 0; i = edges[i].next)
            {
                int v = edges[i].to;
                int flow = edges[i].w;
                if (flow > 0 && level[v] == 0) 
                {
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        return (level[t] != 0);
    }

    int dfs(int p, int cur_flow)
    {
        if (p == t)
        {
            return cur_flow;
        }
        int ret = 0;
        for (int i = cur[p]; i != 0; i = edges[i].next)
        {
            cur[p] = i;
            int v = edges[i].to, vol = edges[i].w;
            if (level[v] == level[p] + 1 && vol > 0)
            {
                int f = dfs(v, min(cur_flow - ret, vol));
                edges[i].w -= f;
                edges[i ^ 1].w += f;
                ret += f;
                if (ret == cur_flow)
                    return ret;
            }
        }
        return ret; 
    }

    int dinic() 
    {
        int max_flow = 0;
        while (bfs())
        {
            max_flow += dfs(s, INF);
        }
        return max_flow;
    }   
} gagtd[27];

signed main()
{
    int n;
    cin >> n;
    
    for (int i = 1; i <= n; ++i)
    {
        cin >> str[i];
    }
    
    for (int i = 1; i <= 26; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            gagtd[i].add(i, j + n, 1);
            gagtd[i].add(j + n, i, 0);
        }
    }
    
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 0; j < str[i].size(); ++j)
        {
            gagtd[str[i][j] - 'a' + 1].add(i, j + 1, 1);
            gagtd[str[i][j] - 'a' + 1].add(j + 1, i, 0);
            gagtd[str[i][j] - 'a' + 1].add(j + 1, 2 * n + 1, INF);
            gagtd[str[i][j] - 'a' + 1].add(2 * n + 1, j + 1, 0);
        }
    }
    
    for (int i = 1; i <= 2 * n + 1; ++i)
    {
        gagtd[i].s = 1;
        gagtd[i].t = 2 * n + 1;
        int results = gagtd[i].dinic();
        if (results == n)
        {
            cout << "YES" << endl;
            return 0;
    	}
    }
    
    cout << "NO" << endl;
    return 0;
}