zoukankan      html  css  js  c++  java
  • USACO 3.3 Riding the Fences

    Riding the Fences

    Farmer John owns a large number of fences that must be repaired annually. He traverses the fences by riding a horse along each and every one of them (and nowhere else) and fixing the broken parts.

    Farmer John is as lazy as the next farmer and hates to ride the same fence twice. Your program must read in a description of a network of fences and tell Farmer John a path to traverse each fence length exactly once, if possible. Farmer J can, if he wishes, start and finish at any fence intersection.

    Every fence connects two fence intersections, which are numbered inclusively from 1 through 500 (though some farms have far fewer than 500 intersections). Any number of fences (>=1) can meet at a fence intersection. It is always possible to ride from any fence to any other fence (i.e., all fences are "connected").

    Your program must output the path of intersections that, if interpreted as a base 500 number, would have the smallest magnitude.

    There will always be at least one solution for each set of input data supplied to your program for testing.

    PROGRAM NAME: fence

    INPUT FORMAT

    Line 1: The number of fences, F (1 <= F <= 1024)
    Line 2..F+1: A pair of integers (1 <= i,j <= 500) that tell which pair of intersections this fence connects.

    SAMPLE INPUT (file fence.in)

    9
    1 2
    2 3
    3 4
    4 2
    4 5
    2 5
    5 6
    5 7
    4 6
    

    OUTPUT FORMAT

    The output consists of F+1 lines, each containing a single integer. Print the number of the starting intersection on the first line, the next intersection's number on the next line, and so on, until the final intersection on the last line. There might be many possible answers to any given input set, but only one is ordered correctly.

    SAMPLE OUTPUT (file fence.out)

    1
    2
    3
    4
    2
    5
    4
    6
    5
    7
    

     ——————————————————————————

    求一个欧拉路径或者一个欧拉回路

    就是这个五百进制的格式问题啊……就是说总是要从最小的点开始走,这样我们可以用邻接矩阵存

    如果有一个点的点度是奇数,那么起点一定是这个点,结束点不会回来

    如果所有点的点度都是偶数,那么选择最小的点为起点,最后会回到这里

     1 /*
     2 ID: ivorysi
     3 PROG: fence
     4 LANG: C++
     5 */
     6 #include <iostream>
     7 #include <cstdio>
     8 #include <cstring>
     9 #include <algorithm>
    10 #include <queue>
    11 #include <set>
    12 #include <vector>
    13 #define siji(i,x,y) for(int i=(x);i<=(y);++i)
    14 #define gongzi(j,x,y) for(int j=(x);j>=(y);--j)
    15 #define xiaosiji(i,x,y) for(int i=(x);i<(y);++i)
    16 #define sigongzi(j,x,y) for(int j=(x);j>(y);--j)
    17 #define inf 0x7fffffff
    18 #define MAXN 400005
    19 #define ivorysi
    20 #define mo 97797977
    21 #define ha 974711
    22 #define ba 47
    23 #define fi first
    24 #define se second
    25 #define pii pair<int,int>
    26 using namespace std;
    27 typedef long long ll;
    28 int adj[600][600];
    29 int size[600];
    30 int po[605];
    31 int path[2016],cnt;
    32 void init() {
    33     int f,u,v;
    34     scanf("%d",&f);
    35     siji(i,1,f) {
    36         scanf("%d%d",&u,&v);
    37         ++size[u];++size[v];
    38         ++adj[u][v];++adj[v][u];
    39     }
    40 }
    41 void dfs(int u) {
    42     while(po[u]<=500) {
    43         while(adj[u][po[u]]) {
    44             --adj[po[u]][u];--adj[u][po[u]];
    45             dfs(po[u]);
    46         }
    47         ++po[u];//自加要放到下面
    48     }
    49     path[++cnt]=u;
    50 }
    51 void solve() {
    52     init();
    53     int val=-1;
    54     siji(i,1,500) if(size[i]%2) {val=i;break;}
    55     if(val==-1) {
    56         siji(i,1,500) if(size[i]!=0) {val=i;break;}
    57     }
    58     dfs(val);
    59     gongzi(i,cnt,1) {
    60         printf("%d
    ",path[i]);
    61     }
    62 }
    63 int main(int argc, char const *argv[])
    64 {
    65 #ifdef ivorysi
    66     freopen("fence.in","r",stdin);
    67     freopen("fence.out","w",stdout);
    68 #else
    69     freopen("f1.in","r",stdin);
    70 #endif
    71     solve();
    72 }

     http://www.cnblogs.com/ivorysi/p/5745005.html

    以前写的超级认真的欧拉回路……但其实USACO上讲的也很好

  • 相关阅读:
    LeetCode 217. 存在重复元素
    LeetCode 48. 旋转图像
    LeetCode 35. 搜索插入位置
    LeetCode 27. 移除元素
    LeetCode 145. 二叉树的后序遍历 (用栈实现后序遍历二叉树的非递归算法)
    LeetCode 328. 奇偶链表
    LeetCode 160. 相交链表 (找出两个链表的公共结点)
    LeetCode 26. 删除排序数组中的重复项
    LeetCode 836. 矩形重叠
    数据库
  • 原文地址:https://www.cnblogs.com/ivorysi/p/6193782.html
Copyright © 2011-2022 走看看