ccf题解

问题描述

　　为了增加公司收入，F公司新开设了物流业务。由于F公司在业界的良好口碑，物流业务一开通即受到了消费者的欢迎，物流业务马上遍及了城市的每条街道。然而，F公司现在只安排了小明一个人负责所有街道的服务。
　　任务虽然繁重，但是小明有足够的信心，他拿到了城市的地图，准备研究最好的方案。城市中有n个交叉路口，m条街道连接在这些交叉路口之间，每条街道的首尾都正好连接着一个交叉路口。除开街道的首尾端点，街道不会在其他位置与其他街道相交。每个交叉路口都至少连接着一条街道，有的交叉路口可能只连接着一条或两条街道。
　　小明希望设计一个方案，从编号为1的交叉路口出发，每次必须沿街道去往街道另一端的路口，再从新的路口出发去往下一个路口，直到所有的街道都经过了正好一次。

输入格式

　　输入的第一行包含两个整数n, m，表示交叉路口的数量和街道的数量，交叉路口从1到n标号。
　　接下来m行，每行两个整数a, b，表示和标号为a的交叉路口和标号为b的交叉路口之间有一条街道，街道是双向的，小明可以从任意一端走向另一端。两个路口之间最多有一条街道。

输出格式

　　如果小明可以经过每条街道正好一次，则输出一行包含m+1个整数p ₁, p ₂, p ₃, ..., p _{m +1}，表示小明经过的路口的顺序，相邻两个整数之间用一个空格分隔。如果有多种方案满足条件，则输出字典序最小的一种方案，即首先保证p ₁最小，p ₁最小的前提下再保证p ₂最小，依此类推。
　　如果不存在方案使得小明经过每条街道正好一次，则输出一个整数-1。

样例输入

4 5
1 2
1 3
1 4
2 4
3 4

样例输出

1 2 4 1 3 4

样例说明

　　城市的地图和小明的路径如下图所示。

样例输入

4 6
1 2
1 3
1 4
2 4
3 4
2 3

样例输出

-1

样例说明

　　城市的地图如下图所示，不存在满足条件的路径。

评测用例规模与约定

　　前30%的评测用例满足：1 ≤ n ≤ 10, n-1 ≤ m ≤ 20。
　　前50%的评测用例满足：1 ≤ n ≤ 100, n-1 ≤ m ≤ 10000。

　　所有评测用例满足：1 ≤ n ≤ 10000，n-1 ≤ m ≤ 100000。

说实话第一眼看到这个题就蒙了，完全不会，就去搜了题解，看看思路也是极好的，这是求是否有欧拉路径，若有，则打印路径，若没有，就输出-1，普及小知识的时间start：

欧拉路径：寻找一条只通过每条边一次的路径

（1）源点和汇点不为同一点

（2）源点与汇点的度数为奇数外，其余的点为偶数

（3）判断奇数度数点个数是否为0或者2，若奇数点个数为2，当起点为偶数的时候，就不是欧拉函数了

欧拉回路：起点和终点是同一点（当所有点是偶数，可以任意得到一条欧拉回路）

无向图：每个顶点的入度是偶数，则存在欧拉回路

有向图：每个顶点的入度和出度相等

下面就贴出一个博客的代码：

#include<iostream>
#include<stack>
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;
const int maxn=10005;
stack<int> st;
vector<int> vec[maxn];
bool map[maxn][maxn];//改成int,就不对了
int vis[maxn];
int cp[maxn];
int n,m;
void pd(int a)
{
    cp[a]=1;
    vector<int>::iterator it;   
    for(it=vec[a].begin();it!=vec[a].end();it++)
    {
        if(!cp[*it])
            pd(*it);
    }
}
void dfs(int a)
{ 
     vector<int>::iterator it;   
    for(it=vec[a].begin();it!=vec[a].end();it++)
    {
         if(!map[a][*it])
         {
             map[a][*it]=1;
             map[*it][a]=1;
             dfs(*it);
             st.push(*it);
         }
     }
}
void prt()
{
    st.push(1);
    while(!st.empty())
    {
        //printf("%d ",st.top());
        int ss=st.top();
        st.pop();
        printf("%d ",ss);
    }
}
int main()
{
    int num=0;
    //memset(cp,0,sizeof(cp));
    //memset(vis,0,sizeof(vis));
    //memset(map,0,sizeof(map));
    for(int i=0;i<maxn;++i)
    {
        cp[i]=vis[i]=0;
    }

    scanf("%d %d",&n,&m);
    int a,b;
    for(int i=0;i<m;++i)
    {
        scanf("%d %d",&a,&b);
        vec[a].push_back(b);
        vec[b].push_back(a);
        vis[a]++;
        vis[b]++;
    }
    int flag=0;
    pd(1);
    for(int i=1;i<=n;++i)
    {
        if(cp[i]==0)
            flag=1;
        else
            break;
    }
    if(flag)
        printf("-1\n");
    else
    {
        for(int i=1;i<=n;++i)
        {
            
            sort(vec[i].begin(),vec[i].end());
            if(vis[i]%2==1)
                ++num;
        }
        if(num==0||num==2)
        {
            if(num==2)
            {
                if(vis[1]%2==1)
                {
                    dfs(1);
                    prt();
                }
                else
                    printf("-1\n");
            }
            else
            {
                 dfs(1);
                 prt();
            }
        }
        else
        {
            printf("-1\n");
        }
    }
    return 0;
}

在此时要注意一个就是bool map[][];因为bool是一个字节，int是4个字节，若改成int，就爆内存了。。。我交了无数次。。。汗。。。。

再贴出我认识的一个大神写的代码，仅仅用了70+ＭＢ，说白了这个题关键是改容器，用＜ｓｅｔ＞，＜ｓｔａｃｋ＞，＜ｈａｓｈ＞，方可达到减少内存，，，但速度越来越慢。。。。。。

废话少说，贴代码：

#include <stdio.h>
#include <set>
using namespace std;
bool map[50005000], connect[10005];
int n, m, mem[1000005];
set<int> edge[10005];
class Stack {
public:
    int p;
    Stack() {
        p = 0;
    }

    void push(int x) {
        mem[p++] = x;
    }

    void print() {
        printf("1");
        for(int i = p - 1; i >= 0; --i)
            printf(" %d", mem[i]);
    }
} stack;

int pos(int x, int y) {
    if (x > y)
        return y + ((x * (x - 1)) >> 1);
    else
        return x + ((y * (y - 1)) >> 1);
}

void pd(int x) {
    connect[x] = 1;
    for (set<int>::iterator it = edge[x].begin(); it != edge[x].end(); ++it)
        if(!connect[*it])
            pd(*it);
}

void dfs(int x) {
    for (set<int>::iterator it = edge[x].begin(); it != edge[x].end(); ++it)
        if (!map[pos(x, *it)]) {
            map[pos(x, *it)] = 1;
            dfs(*it);
            stack.push(*it);
        }
}

int main() {
    if(fopen("in.txt","r")) freopen("in.txt","r",stdin);
    scanf("%d %d", &n, &m);
    
    int x, y;
    for (int i = 0; i < m; ++i) {
        scanf("%d %d", &x, &y);
        edge[x].insert(y);
        edge[y].insert(x);
        mem[x] = !mem[x];
        mem[y] = !mem[y];
    }

    pd(1);
    for (int i = 1; i <= n; ++i)
        if (!connect[i]) {
            printf("-1\n");
            return 0;
        }

    int o = 0;
    for (int i = 1; i <= n; ++i)
        o += mem[i];

    if ((o == 2 && mem[1] == 1) || o == 0) {
        dfs(1);
        stack.print();
    } else {
        printf("-1\n");
    }
    return 0;
}

再一个，还可以是bool map数组改成set<int>map[maxn];内存可以减少到30+，