CF #228 div1 B. Fox and Minimal path

题目链接：http://codeforces.com/problemset/problem/388/B

大意是用不超过1000个点构造一张边权为1的无向图，使得点1到点2的最短路的个数为给定值k，其中k为不超过1e9的正整数，输出邻接矩阵

构造方法也不止一种

有一种分层构造方法是这样的，

第i层的点与1号点距离为i-1

第一层放置1号点

第二层放置3号和4号点，分别与上一层的1号点相连，他们的最短路为1，且个数也为1

接下来每一层都会比上一层的点数要多1，第i+1层，首先与第i层的前i个点相连，然后第i+1个点与第i层的所有点相连

这样构造的话，最短路个数按照层表示会是

1

1 1

1 1 2

1 1 2 4

1 1 2 4 8

1 1 2 4 8 16

这样下去。主要就是利用了1+2+...+2^n=2^(n+1)-1 再多一个个数为1的点就能凑成下一个2的幂了

其他的构造方法还可以是不断地分出2个岔路，再汇合，再分岔，这样的话每个汇合点也是一个2的幂，但是要注意每个汇合点不能直接连到2号点，因为每个汇合点与1号点距离是不相等的，处理方法可以是往下拖到一条“总线”上，总线末端与2号点相连

下面是第一种构造方式的代码

 import java.io.OutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 import java.io.IOException;
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.io.InputStream;

 public class Main {
     public static void main(String[] args) {
         InputStream inputStream = System.in;
         OutputStream outputStream = System.out;
         InputReader in = new InputReader(inputStream);
         PrintWriter out = new PrintWriter(outputStream);
         Task solver = new Task();
         solver.solve(1, in, out);
         out.close();
     }

     static class Task {
         void addEdge(boolean[][] g, int u, int v) {
             g[u][v] = true;
             g[v][u] = true;
         }

         public void solve(int testNumber, InputReader in, PrintWriter out) {
             int k = in.nextInt();
             boolean[][] g = new boolean[1001][10001];
             int n = 2;
             int from = 0, to = 1;
             for (int p = 1, l = 1; p <= k; p <<= 1, l++) {
                 int nfrom = n;
                 for (int i = from; i < to; i++) {
                     addEdge(g, i, n++);
                 }
                 for (int i = from; i < to; i++) {
                     addEdge(g, i, n);
                 }
                 from = nfrom;
                 to = ++n;
             }
             for (int i = from + 1; i < to; i++) {
                 if ((k & (1 << i - from - 1)) != 0) {
                     addEdge(g, i, 1);
                 }
             }
             out.println(n);
             for (int i = 0; i < n; i++) {
                 for (int j = 0; j < n; j++) {
                     out.print((g[i][j] ? "Y" : "N"));
                 }
                 out.println();
             }
         }

     }

     static class InputReader {
         private final BufferedReader reader;
         private StringTokenizer tokenizer;

         public InputReader(InputStream stream) {
             reader = new BufferedReader(new InputStreamReader(stream));
             tokenizer = null;
         }

         public String next() {
             while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                 try {
                     tokenizer = new StringTokenizer(reader.readLine());
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
             }
             return tokenizer.nextToken();
         }

         public int nextInt() {
             return Integer.parseInt(next());
         }

     }
 }