zoukankan      html  css  js  c++  java
  • CCF 2016-12 送货

    问题描述

    试题编号: 201512-4
    试题名称: 送货
    时间限制: 1.0s
    内存限制: 256.0MB
    问题描述:
    问题描述
      为了增加公司收入,F公司新开设了物流业务。由于F公司在业界的良好口碑,物流业务一开通即受到了消费者的欢迎,物流业务马上遍及了城市的每条街道。然而,F公司现在只安排了小明一个人负责所有街道的服务。
      任务虽然繁重,但是小明有足够的信心,他拿到了城市的地图,准备研究最好的方案。城市中有n个交叉路口,m条街道连接在这些交叉路口之间,每条街道的首尾都正好连接着一个交叉路口。除开街道的首尾端点,街道不会在其他位置与其他街道相交。每个交叉路口都至少连接着一条街道,有的交叉路口可能只连接着一条或两条街道。
      小明希望设计一个方案,从编号为1的交叉路口出发,每次必须沿街道去往街道另一端的路口,再从新的路口出发去往下一个路口,直到所有的街道都经过了正好一次。
    输入格式
      输入的第一行包含两个整数n, m,表示交叉路口的数量和街道的数量,交叉路口从1到n标号。
      接下来m行,每行两个整数a, b,表示和标号为a的交叉路口和标号为b的交叉路口之间有一条街道,街道是双向的,小明可以从任意一端走向另一端。两个路口之间最多有一条街道。
    输出格式
      如果小明可以经过每条街道正好一次,则输出一行包含m+1个整数p1, p2, p3, ..., pm+1,表示小明经过的路口的顺序,相邻两个整数之间用一个空格分隔。如果有多种方案满足条件,则输出字典序最小的一种方案,即首先保证p1最小,p1最小的前提下再保证p2最小,依此类推。
      如果不存在方案使得小明经过每条街道正好一次,则输出一个整数-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
     
     
    看上去很简单的一道题,因为总是出各种莫名的bug,所以,卡了有几个点吧..
    邻接表比较容易吧...好像还有别的什么方法...不过裸的dfs就可以过就是了..
    无限RE之后发现vis数组开小了...然后就是...TLE...70分...然后,换一种排序的方法,感觉唯一的不同就是这样a->b和b->a两条边就可以紧挨着了。
    这样的话,搜索过程中,最后一次搜索到的路径一定是字典序最小的,省略了栈存储路径,然后就100分了。
    超时代码:70分
    // 超时stack版
    
    #include <stdio.h>
    #include <string.h>
    #include <algorithm>
    #include <iostream>
    #include <stack>
    #define maxn 200100
    using namespace std;
    
    struct Node {
        int u, v, nxt;
    }edge[maxn];
    
    struct Road {
        int u, v;
        int sum;
    }road[maxn];
    
    int head[maxn];
    int tot;
    
    bool cmp(Road a, Road b) {
        if (a.u == b.u) return a.v > b.v;
        return a.u < b.u;
    }
    
    bool ans;
    
    void addEdge(int u, int v) {
        edge[tot].u = u;
        edge[tot].v = v;
        edge[tot].nxt = head[u];
        head[u] = tot++;
    }
    
    bool vis[10010][10010];
    
    bool check() {
        for (int i=0; i<tot; ++i) {
            int tu = edge[i].u, tv = edge[i].v;
            if (!vis[tu][tv] && !vis[tv][tu])
                return false;
        }
        return true;
    }
    
    
    stack<int>que;
    int top, tail;
    int anscnt = 0;
    int anss[maxn];
    
    void dfs(int num) {
        if (ans) return;
        if (check()) {
            ans = true;
            bool first = true;
            anscnt = 0;
            int tsize = que.size();
            while(anscnt < tsize) {
                anss[anscnt++] = que.top();
                que.pop();
            }
            for (int i=anscnt-1; i>=0; --i) {
                if (first) first = false;
                else printf(" ");
                printf("%d", anss[i]);
            }
            printf("
    ");
            return;
        }
        for (int i=head[num]; i!=-1; i=edge[i].nxt) {
            int tu = edge[i].u, tv = edge[i].v;
            if (!vis[tu][tv] && !vis[tv][tu]) {
                vis[tu][tv] = 1;
                vis[tv][tu] = 1;
                que.push(tv);
                dfs(tv);
                if (ans) return;
                que.pop();
                vis[tu][tv] = 0;
                vis[tv][tu] = 0;
            }
        }
        return;
    }
    
    int degree[maxn];
    
    int main() {
        int n, m;
        while(~scanf("%d%d", &n, &m)) {
            memset(head, -1, sizeof(head));
            memset(vis, 0, sizeof(vis));
            memset(degree, 0, sizeof(degree));
    
            int cnt = 0;
            for (int i=0; i<m; ++i) {
                int u, v;
                scanf("%d%d", &u, &v);
                degree[u]++, degree[v]++;
                road[cnt].u = u, road[cnt].v = v, road[cnt++].sum = u+v;
                road[cnt].u = v, road[cnt].v = u, road[cnt++].sum = u+v;
            }
            sort(road, road+cnt, cmp);
            tot = 0;
    
            for (int i=0; i<cnt; ++i) {
                addEdge(road[i].u, road[i].v);
            }
    
            int judge = 0;
            for (int i=1; i<=n; ++i) {
                if (degree[i] & 1)
                    judge++;
            }
            if (! (judge == 0 || judge == 2)) {
                printf("-1
    ");
                continue;
            }
            ans = false;
            que.push(1);
            dfs(1);
           // cout << "++++++
    ";
            if (ans == false) {
               printf("-1
    ");
            }
        }
        return 0;
    }
    

    100分版:

    //100分版
    
    #include <stdio.h>
    #include <string.h>
    #include <algorithm>
    #include <iostream>
    #define maxn 200100
    using namespace std;
    
    struct Node {
        int u, v, nxt;
    }edge[maxn];
    
    struct Road {
        int u, v;
        int sum;
    }road[maxn];
    
    int head[maxn];
    int tot;
    
    bool cmp(Road a, Road b) {
    //    if (a.sum == b.sum && a.u == b.u) return a.v > b.v;
    //    if (a.sum == b.sum && a.v == b.v) return a.u > b.u;
        return a.sum > b.sum;
    }
    
    bool ans;
    
    void addEdge(int u, int v) {
        edge[tot].u = u;
        edge[tot].v = v;
        edge[tot].nxt = head[u];
        head[u] = tot++;
    }
    
    bool vis[10010][10010];
    
    int que[10000000];
    int top, tail;
    bool visnum[10010];
    
    void dfs(int num) {
        visnum[num] = 1;
        for (int i=head[num]; i!=-1; i=edge[i].nxt) {
            int tu = edge[i].u, tv = edge[i].v;
            if (!vis[tu][tv] && !vis[tv][tu]) {
                vis[tu][tv] = 1;
                vis[tv][tu] = 1;
                dfs(tv);
            }
        }
        que[tail++] = num;
        return;
    }
    
    int n;
    
    bool check() {
        for (int i=0; i<tot; ++i) {
            int tu = edge[i].u, tv = edge[i].v;
            if (!vis[tu][tv] && !vis[tv][tu])
                return false;
        }
        return true;
    }
    
    //bool check() {
    //    for (int i=1; i<=n; ++i) {
    //        if (!visnum[i]) return false;
    //    }
    //    return true;
    //}
    
    int degree[maxn];
    
    int main() {
        int m;
        while(~scanf("%d%d", &n, &m)) {
            memset(head, -1, sizeof(head));
            memset(vis, 0, sizeof(vis));
            memset(degree, 0, sizeof(degree));
            memset(visnum, 0, sizeof(visnum));
    
            int cnt = 0;
            for (int i=0; i<m; ++i) {
                int u, v;
                scanf("%d%d", &u, &v);
                degree[u]++, degree[v]++;
                road[cnt].u = u, road[cnt].v = v, road[cnt++].sum = u+v;
            }
            sort(road, road+cnt, cmp);
            tot = 0;
    
            for (int i=0; i<cnt; ++i) {
                addEdge(road[i].u, road[i].v);
                addEdge(road[i].v, road[i].u);
            }
    
    //        int judge = 0;
    //        for (int i=1; i<=n; ++i) {
    //            if (degree[i] & 1)
    //                judge++;
    //        }
    //        if (!(judge == 0 || judge == 2)) {
    //            printf("-1
    ");
    //            continue;
    //        }
            ans = false;
            tail = 0;
            dfs(1);
            if (!check()) {
                cout << "-1
    ";
                continue;
            }
            for (int i=tail-1; i>=0; --i) {
                if (i == tail-1)
                cout << que[i];
                else cout << " " <<  que[i];
            }
            cout << endl;
        }
        return 0;
    }
    

    在dfs之前可以用欧拉路径判断一下是不是存在一笔画,不判断也不会超时。

    然后,第二个程序的代码里的两个check()函数,都是可以的,我觉得判断每个边是不是都被走过了即可。

    总之这是一道稍微转了个弯的题,被我做复杂了。(汗)大概这就是代码能力吧..bug太多..

  • 相关阅读:
    理解闭包
    .net 应用程序执行过程
    Lambda 表达式
    栈的应用
    C# string
    自包含 与 自描述
    C# 值类型 与 引用类型
    C# 装箱 与 拆箱
    sql server分页的两种方法比较
    九月天开博日志
  • 原文地址:https://www.cnblogs.com/icode-girl/p/5369737.html
Copyright © 2011-2022 走看看