Codeforces Round #228 (Div. 1) B

B. Fox and Minimal path

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Fox Ciel wants to write a task for a programming contest. The task is: "You are given a simple undirected graph with n vertexes. Each its edge has unit length. You should calculate the number of shortest paths between vertex 1 and vertex 2."

Same with some writers, she wants to make an example with some certain output: for example, her birthday or the number of her boyfriend. Can you help her to make a test case with answer equal exactly to k?

Input

The first line contains a single integer k (1 ≤ k ≤ 109).

Output

You should output a graph G with n vertexes (2 ≤ n ≤ 1000). There must be exactly k shortest paths between vertex 1 and vertex 2 of the graph.

The first line must contain an integer n. Then adjacency matrix G with n rows and n columns must follow. Each element of the matrix must be 'N' or 'Y'. If Gij is 'Y', then graph G has a edge connecting vertex i and vertex j. Consider the graph vertexes are numbered from 1 ton.

The graph must be undirected and simple: Gii = 'N' and Gij = Gji must hold. And there must be at least one path between vertex 1 and vertex 2. It's guaranteed that the answer exists. If there multiple correct answers, you can output any of them.

Sample test(s)

input

2

output

4
NNYY
NNYY
YYNN
YYNN

input

9

output

8
NNYYYNNN
NNNNNYYY
YNNNNYYY
YNNNNYYY
YNNNNYYY
NYYYYNNN
NYYYYNNN
NYYYYNNN

input

1

output

2
NY
YN

Note

In first example, there are 2 shortest paths: 1-3-2 and 1-4-2.

In second example, there are 9 shortest paths: 1-3-6-2, 1-3-7-2, 1-3-8-2, 1-4-6-2, 1-4-7-2, 1-4-8-2, 1-5-6-2, 1-5-7-2, 1-5-8-2.

整数N拆写成二进制。

如 15 = 2^3 + 2^2 + 2^1 +2^0 ；

#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <stdlib.h>
#include <vector>
#include <set>
#include <math.h>
#include <map>
using namespace std;
typedef long long LL ;

int pow2[] ;
vector<int> ans ;
vector<int> ::iterator it ;
map<int ,int>my_hash ;
int shortest ;
int id ;
const int S =  ;
const int T =  ;
bool grid[][] ;

void make_line(int dot , int type){
     vector < pair<int ,int> > me ;
     vector < pair<int ,int> > ::iterator it ;
     me.clear() ;
     for(int i =  ; i <= dot ; i++){
        me.push_back(make_pair(id,id+)) ;
        id +=  ;
     }
     if(type ==  && dot != shortest){
         my_hash.clear() ;
         for(int i = dot +  ; i <= shortest ; i++){
            me.push_back(make_pair(id,id)) ;
            my_hash[i] = id ;
            id +=  ;
         }
     }
     it = me.begin() ;
     grid[S][it->first] = grid[S][it->second] =  ;
     grid[it->first][S] = grid[it->second][S] =  ;
     if(type ==  && dot != shortest){
         it = me.end() - ;
         grid[it->first][T] = grid[it->second][T] =  ;
         grid[T][it->first] = grid[T][it->second] =  ;
     }
     else {
         it = me.end() -  ;
         int v = (dot == shortest ? T : my_hash[dot+]) ;
         grid[it->first][v] = grid[it->second][v] =  ;
         grid[v][it->first] = grid[v][it->second] =  ;
     }
     for(int i =  ; i < me.size() ; i++){
          int u1 = me[i-].first ;
          int u2 = me[i-].second ;
          int v1 = me[i].first ;
          int v2 = me[i].second ;
          grid[u1][v1] = grid[u1][v2] =  ;
          grid[u2][v1] = grid[u2][v2] =  ;

          grid[v1][u1] = grid[v1][u2] =  ;
          grid[v2][u1] = grid[v2][u2] =  ;
     }
}

void output(){
     int n = id -  , i , j ;
     cout<<n<<endl ;
     for(i =  ; i <= n ; i++){
        for(j =  ; j <= n ; j++)
            printf("%s",grid[i][j]?"Y":"N") ;
        puts("") ;
     }
}

int main(){
    int i  , k ,sum =  ;
    pow2[] =  ;
    for(i =  ; i <=   ; i++)
        pow2[i] = pow2[i-] *  ;
    cin>>k ;
    if(k == ){
        puts("") ;
        puts("NY") ;
        puts("YN") ;
        return  ;
    }
    ans.clear() ;
    for(i =  ; i >=  ; i--){
        if(k >= pow2[i]){
            ans.push_back(i) ;
            k -= pow2[i] ;
        }
    }
    memset(grid,,sizeof(grid)) ;
    shortest = *ans.begin() ;
    id =  ;
    make_line(ans[ans.size()-] ,) ;
    for(i = ans.size() -  ; i >=  ; i--)
        make_line(ans[i] , ) ;
    output() ;
    return  ;
}