Riding the Fences USACO 3.3 欧拉路径(dfs+floodfill)

额,我是直接dfs的思路,但是到case 5过不去了,感觉是太慢了。然后网上看题解,题目原型就是欧拉路径,

欧拉路径存在的条件是 要么点的度都是偶数,要么只有两个点的度是奇数。如果是两个点的度是奇数,起点和终点一定是这两个点,

然后我就加了一个判断,如果是有奇数度的点,取较小的点作为起点dfs。

dfs写的很丑,没组织好,还根据初始点判断,其实组织好没有这么麻烦...

但是到7还是过不去,继续看题解,发现有个大牛dfs同时加了个floodfill

其实我一直以为floodfill就是dfs和bfs...

然后我仿照加了个勉强过了

/*

ID: hubiao cave

PROG: fence

LANG: C++

*/




#include<iostream>

#include<fstream>
#include<cstring>
#include<vector>
#include<deque>
#include<algorithm>

using namespace std;



vector<int> g_vertex_maps[501];
deque<int>  g_vertex_sequence;
int g_visit[501][501];
int g_fence_number;
int g_max_vertex,g_min_vertex=1;
int g_count;
int node_counter[501];
bool g_isover=false;
int special_start_vertex=8888;

void dfs(int);
bool floodfill(long node);
 ofstream fout("fence.out");
int main()

{

    ifstream fin("fence.in");

    //ofstream fout("fence.out");
    
    fin>>g_fence_number;
    
    int a,b;
    for(int i=0;i<g_fence_number;i++)
    {
        fin>>a>>b;
        if(i==0)
            g_min_vertex=min(a,b);

        g_vertex_maps[a].push_back(b);
        g_vertex_maps[b].push_back(a);

        node_counter[a]++;
        node_counter[b]++;
        g_visit[a][b]++;
        g_visit[b][a]++;

        g_max_vertex=g_max_vertex>max(a,b)?g_max_vertex:max(a,b);
        g_min_vertex=g_min_vertex<min(a,b)?g_min_vertex:min(a,b);

    }

    for(int i=g_min_vertex;i<=g_max_vertex;i++)
    {
        if(!g_vertex_maps[i].empty())
            sort(g_vertex_maps[i].begin(),g_vertex_maps[i].end());

        if(g_vertex_maps[i].size()%2==1)//欧拉路径 找度为奇数的点为起点加速
            special_start_vertex=min(special_start_vertex,i);
            
    }


    if(special_start_vertex==8888)
        dfs(0);
    else
        dfs(special_start_vertex);
    

    return 0;


}

void dfs(int start_vertex)
{

    if(g_count==g_fence_number)
    {
        if(special_start_vertex!=8888)
            g_vertex_sequence.push_front(special_start_vertex);
        for(int i=0;i<g_vertex_sequence.size();i++)
            fout<<g_vertex_sequence[i]<<endl;
        g_isover=true;
        exit(0);
        //return;
    }
    
    if(start_vertex!=0&&!floodfill(start_vertex))
    {
        return;
    }

    if(start_vertex==0)
    {
        for(int i=g_min_vertex;i<=g_max_vertex;i++)
        {

            for(int j=0;j<g_vertex_maps[i].size();j++)
            {
                g_count++;
                g_visit[i][g_vertex_maps[i][j]]--;
                g_visit[g_vertex_maps[i][j]][i]--;
                g_vertex_sequence.push_back(i);
                g_vertex_sequence.push_back(g_vertex_maps[i][j]);
                node_counter[i]--;
                node_counter[g_vertex_maps[i][j]]--;

                dfs(g_vertex_maps[i][j]);

                if(g_isover)
                    return;

                node_counter[i]++;
                node_counter[g_vertex_maps[i][j]]++;

                g_vertex_sequence.pop_back();
                g_vertex_sequence.pop_back();
                g_visit[i][g_vertex_maps[i][j]]++;
                g_visit[g_vertex_maps[i][j]][i]++;

                g_count--;
            }
        }
    }
    else
    {
        for(int i=0;i<g_vertex_maps[start_vertex].size();i++)
        {
            int end_vertex=g_vertex_maps[start_vertex][i];
            if(g_visit[start_vertex][end_vertex]>0)
            {
                g_count++;
                g_visit[start_vertex][end_vertex]--;
                g_visit[end_vertex][start_vertex]--;
                g_vertex_sequence.push_back(end_vertex);

                node_counter[start_vertex]--;
                node_counter[end_vertex]--;

                dfs(end_vertex);
                if(g_isover)
                    return;

                node_counter[start_vertex]++;
                node_counter[end_vertex]++;

                g_count--;
                g_visit[start_vertex][end_vertex]++;
                g_visit[end_vertex][start_vertex]++;
                g_vertex_sequence.pop_back();
            }

        }
    }
}

bool floodfill(long node)
{
    int *stack=new int[501],top=-1;
    bool vis[501];
    //for(int i=0;i<=500;i++)
        memset(vis,0,sizeof(vis));

    stack[++top]=node;
    vis[node]=true;
    while(top>-1)
    {
        int m=stack[top--];
        for(int i=g_min_vertex;i<=g_max_vertex;i++)
        {
            if(g_visit[m][i]&&!vis[i])
            {
            stack[++top]=i;
            vis[i]=true;
            }
        }
    }

    for(int i=g_min_vertex;i<=g_max_vertex;i++)
    {
        if(!vis[i]&&node_counter[i])
        {
            delete stack;
            return false;
        }
    }
    delete stack;
    return true;

}