C++博客-王之昊的小屋-文章分类-sgu

sgu 118

王之昊 — Wed, 15 Dec 2010 03:48:00 GMT

对于“数根”（定义见Let f(n) be a sum of digits for positive integer n. If f(n) is one-digit number then it is a digital root for n and otherwise digital root of n is equal to digital root of f(n).）注意这里只定义正整数的“数根”，所以已经把 0 排除了。

结论: 数根f(n)与n模9同余，且f(n)的范围属于[1,9].

证明：如果n = a_m*10^m + a_m-1*10^m-1 +...+ a₀*10⁰, 令g(n) = a_m+a_m-1+...+a₀.

n -> [n₀=g(n)] -> [n₁=g(n₀)] -> [n₂=g(n₁)] -> ... -> f(n)

中间的每个环节都是模9同余的，传递下去，所以n和f(n)也是模9同余的

1
2import java.io.FileNotFoundException;
3import java.util.Scanner;
4
5
6/*
7 * To change this template, choose Tools | Templates
8 * and open the template in the editor.
9 */
10/**
11 *
12 * @author wangzhihao
13 */
14class Seq {
15
16    int[] A;
17
18    Seq(int[] a) {
19    A = a;
20    }
21    int DigitSum() {
22    int res = 0, term = 1;
23    for (int i = 0; i < A.length; i++) {
24        term = term * ( A[i] % 9) % 9;
25        res = ( res + term ) % 9;
26    }
27    return res == 0 ? 9 : res;
28    }
29}
30
31public class Solution {
32
33    /**
34     * @param args the command line arguments
35     */
36    public static void main(String[] args) throws FileNotFoundException {
37    Scanner sc = new Scanner(System.in);
38    int testCase = sc.nextInt();
39    for (int cas = 1; cas <= testCase; cas++) {
40        int n = sc.nextInt();
41        int[] a = new int[n];
42        for (int i = 0; i < n; i++) {
43        a[i] = sc.nextInt();
44        }
45        Seq seq = new Seq(a);
46        System.out.println(seq.DigitSum());
47    }
48    }
49}
50

王之昊 2010-12-15 11:48 发表评论

sgu 222

王之昊 — Tue, 07 Dec 2010 13:12:00 GMT

sgu 221是互不攻击的象，这次是互不攻击的车。这个比较简单，如果k > n直接无解,否则答案为C( n, k )*C( n, k )*( k! )

accept code

1
2 import java.util.Scanner;
3 import java.util.*;
4 import java.math.BigInteger;
5
6 class rook{
7     int n, k;
8
9     long [][]C;
10
11     rook(int _n, int _k){
12         n = _n;
13         k = _k;
14     }
15
16     long fac(int k){
17         if(k==0)
18             return 1;
19         else
20             return k * fac(k-1);
21     }
22
23     long count(){
24
25         C = new long[n+1][n+1];
26
27         for(int i = 0; i <= n; i++){
28             C[i][0] = C[i][i] = 1;
29             for(int j = 1; j < i; j++)
30                 C[i][j] = C[i-1][j-1] + C[i-1][j];
31         }
32
33         if(n < k){
34             return 0;
35         }
36         else{
37             long kk = C[n][k];
38             return kk * kk * fac( k );
39         }
40     }
41 }
42
43 public class Solution{
44     public static void main(String[] args)throws Exception{
45         Scanner sc = new Scanner(System.in);
46
47         rook r = new rook( sc.nextInt(), sc.nextInt() );
48
49         System.out.println( r.count() );
50     }
51 }

王之昊 2010-12-07 21:12 发表评论

sgu 221

王之昊 — Tue, 07 Dec 2010 12:33:00 GMT

这是黑书上的一道例题(P243)，在一个n*n的国际象棋棋盘上，放k只象，有多少种方法使得象之间不会攻击。

首先第一个观察是白色格子和黑色格子是独立的，可以分开考虑，注意二者不一定对称。然后旋转棋盘，得到一个菱形的期盼，注意到行列顺序是无关的，所以可以交换行列，从小到大开始dp。

附录一：accept代码（dp）

1 //dp,黑书P243
2
3 import java.util.Scanner;
4 import java.util.*;
5 import java.math.BigInteger;
6
7 class biShop{
8     int n, k;
9     biShop(int _n, int _k){
10         n = _n;
11         k = _k;
12     }
13
14     BigInteger [] countOneSide(Vector<Integer> upper){
15         int [] upp = new int[upper.size()];
16         for(int i = 0; i < upp.length; i++){
17             upp[i] = upper.get(i);
18         }
19         Arrays.sort(upp);
20
21         BigInteger [] pre, now;
22         now = new BigInteger[1];
23         now[0] = BigInteger.ONE;
24
25         for(int i = 0; i < upp.length; i++){
26             pre = now;
27             now = new BigInteger[ upp[i] + 1 ];
28             for(int j = 0; j < now.length; j++){
29                 now[j] = BigInteger.ZERO;
30                 if( j < pre.length )
31                     now[j] = now[j].add( pre[j] );
32                 if( 0 < j && j <= pre.length)
33                     now[j] = now[j]. add( pre[j-1].multiply(BigInteger.valueOf(upp[i] - j + 1)) );
34             }
35         }
36         return now;
37     }
38
39     BigInteger count(){
40         Vector<Integer> A = new Vector<Integer>();
41         Vector<Integer> B = new Vector<Integer>();
42
43         A.add(n);
44         for(int i = n-1, j = 0; i > 0; i--, j++){
45             if( (j & 1) == 0){
46                 B.add(i);
47                 B.add(i);
48             }else{
49                 A.add(i);
50                 A.add(i);
51             }
52         }
53
54         BigInteger [] a = countOneSide(A);
55         BigInteger [] b = countOneSide(B);
56         BigInteger res = BigInteger.ZERO;
57
58         for(int i = 0; i <= k; i++){
59             if(i >= a.length || k - i >= b.length)continue;
60             res = res.add( a[i] .multiply( b[k-i]) );
61         }
62         return res;
63     }
64 }
65
66 public class Solution{
67     public static void main(String[] args)throws Exception{
68         Scanner sc = new Scanner(System.in);
69
70         biShop b = new biShop( sc.nextInt(), sc.nextInt() );
71
72         System.out.println( b.count() );
73     }
74 }

王之昊 2010-12-07 20:33 发表评论

sgu 502

王之昊 — Tue, 07 Dec 2010 10:23:00 GMT

题目大意是给你一个数 n (1<=n <= 10¹⁷), 现在可以重排 n 的数位，寻找一种排列使得其能够整除 17。

开始写了一个集合DP的代码。结果TLE，感觉比较奇怪，算复杂度是17*17*(2^17)=3千多万。不过过了300+的人，做到这里就感觉自己做复杂了。

后来才发现直接搜可以跑到52ms，不过到现在还是不会估计搜索的效率。只是感觉搜索很强大。

附录一：TLE代码（集合DP）

1 import java.util.Scanner;
2
3 class Permutation{
4     int []digits;
5     int [][]visit;
6     int size;
7
8     void read(){
9         Scanner sc = new Scanner(System.in);
10         String str = sc.next();
11         digits = new int[str.length()];
12         for(int i = 0; i < str.length(); i++)
13             digits[i] = str.charAt(i) - '0';
14
15         size = 1 << digits.length;
16         visit = new int[size][17];
17         for(int i = 0; i < size; i++)
18             for(int j = 0; j < 17; j++){
19                 visit[i][j] = -1;
20             }
21     }
22
23     boolean find(int a, int b){
24
25         if(a==0)return b==0;
26
27         if(visit[a][b] == 0)return false;
28         if(visit[a][b] == 1)return true;
29
30         for(int i = 0; i < digits.length; i++){
31             if( ( (1<<i) & a ) == 0)continue;
32
33             int na = a ^ (1<<i);
34             int nb = (17 + b - digits[i]) * 12 % 17;
35             if(na == 0 && digits[i] == 0) continue;
36
37             if( find( na, nb) ){
38                 visit[a][b] = 1;
39                 return true;
40             }
41         }
42
43         visit[a][b] = 0;
44         return false;
45     }
46
47     void print(int a, int b){
48         if( a == 0)return;
49         for(int i = 0; i < digits.length; i++){
50             if( ( (1<<i) & a ) == 0)continue;
51
52             int na = a ^ (1<<i);
53             int nb = (17 + b - digits[i]) * 12 % 17;
54             if(na == 0 && digits[i] == 0) continue;
55
56             if( find( na, nb) ){
57                 print(na, nb);
58                 System.out.print(digits[i]);
59                 break;
60             }
61         }
62     }
63
64     void work(){
65         if( find(size-1, 0) )
66         {
67             print(size-1, 0);
68             System.out.println();
69         }
70         else
71             System.out.println(-1);
72     }
73 }
74
75 public class Solution{
76     public static void main(String[] args)throws Exception{
77         Permutation P = new Permutation();
78         P.read();
79         P.work();
80     }
81 }

附录二：Accept代码（dfs）

1 import java.util.Scanner;
2 import java.util.Arrays;
3 class Permutation{
4     int []digits;
5     int []ans;
6     static int size = 10;
7
8     void read(){
9         Scanner sc = new Scanner(System.in);
10         String str = sc.next();
11
12         ans = new int[ str.length() ];
13         digits = new int[size];
14         Arrays.fill(digits, 0);
15
16         for(int i = 0; i < str.length(); i++)
17             digits[ str.charAt(i) - '0' ] ++ ;
18     }
19
20     boolean dfs(int len, int res){
21         if(len == ans.length)return res == 0;
22
23         for(int i = 0; i < size; i++){
24             if(i==0 && len == 0)continue;
25             if(digits[i] > 0){
26                 digits[i]--;
27
28                 ans[len] = i;
29                 if(dfs(len+1, (res*10 + i) % 17) )return true;
30
31                 digits[i]++;
32             }
33         }
34         return false;
35     }
36
37     void work(){
38         if( dfs(0, 0) ){
39             for(int i = 0; i < ans.length; i++)
40                 System.out.print(ans[i]);
41             System.out.println();
42         }
43         else
44             System.out.println(-1);
45     }
46 }
47
48 public class Solution{
49     public static void main(String[] args)throws Exception{
50         Permutation P = new Permutation();
51         P.read();
52         P.work();
53     }
54 }

王之昊 2010-12-07 18:23 发表评论