A.  

題目大意是，給你一個初始的整數，然後用他*1, * 2,*3 ....，並把所有出現過的數字記錄下來， 問什麼時候0～9所有數字都出現了一遍。

剛開始還懷疑有沒有可能死迴圈， 後來沒想直接跑了一個1～100000的看了下，都有結果，就直接暴力上了。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <string>
#define INF 1000000007
using namespace std;
long long gao(int x) {
    int v[10];
    memset(v, 0, sizeof(v));
    int cnt = 1;
    while(true) {
        long long now = (long long)cnt * (long long)x;
        while(now) {
            v[now % 10] = 1;
            now /= 10;
        }
        int flag = 1;
        for(int i = 0; i < 10; i++) {
            if(v[i] == 0) {
                flag = 0;
                break;
            }
        }
        if(flag) return (long long)cnt * (long long)x;
        cnt++;
    }
}
int main() {
    int T, cas = 0, n;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n); 
        if(n == 0) {
            printf("Case #%d: INSOMNIA\n", ++cas);
            continue;
        }
        long long ans = gao(n);
        printf("Case #%d: %lld\n", ++cas, ans);
    }
	return 0;
}
 

B. 

給出一個棧序列，是由若干'+'和'-' 組成的。每次允許的操作是從棧頂取出若干元素，整體倒過來放進棧中，倒過來後'+'將變成'-'，反之亦然。

問用最少的操作使得整個序列都是'+'

這次完全沒想別的直接上dp了，而正解好像只需要統計有多少段就行了。

dp[i][2]有兩個狀態，分別表示從0到i，整個變成'-'需要的運算元和變成'+'的操作

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
char s[111];
int dp[111][2];
int main() {
    int T, cas = 0;
    scanf("%d", &T);
    while(T--) {
        scanf("%s", s); 
        dp[0][0] = dp[0][1] = 0;
        int len = strlen(s);
        for(int i = 0; i < len; i++) {
            if(s[i] == '-') {
                dp[i + 1][0] = min(dp[i][0], dp[i][1] + 1);
                dp[i + 1][1] = dp[i + 1][0] + 1;
            } else {
                dp[i + 1][1] = min(dp[i][1], dp[i][0] + 1);
                dp[i + 1][0] = dp[i + 1][1] + 1;
            }
        }
        printf("Case #%d: %d\n", ++cas, dp[len][1]);
    }
    return 0;
}
 

C. 構造題。

給一個長度n,一個數量J 

問你是否能夠找到J個長度為n的二進位制數，使得他在二進位制，三進位制....九進位制，十進位制時都不是素數，並輸出相應的一個因子

我的做法是直接構造，指定每個進位制的因子分別為3,2,5,2,7,2,9,2,11 這樣。或者3,2,3,2,7,2,3,2,3這樣

然後開始構造二進位制串，每個串中最多四重迴圈列舉位置，計算餘數。 就可以了。

程式碼非常醜陋。就不貼了。

但是這個題顯然有更直接的做法。來自昂神。

構造一個諸如1????11????1 這樣的串，其中?隨意填寫0或者1

那麼因子就是1????1  並且對任意進位制都符合。 這解法又直接又簡潔。

D. 這題題意大意就是給了一個分形。

原始串中包含L或者G，長度為K， 迭代時，串中L會變成原始串，G會變成K個G。

迭代C次，長度就是K^C 

現在給你經過若干次迭代後的串， 問你是否能最多檢視S處元素的情況下判別出原始串是否有G。

那麼對於小資料， 比較簡單了。因為S＝ K。

我們首先對原始串的任意一個位置，  假設該處為G ，那麼在最終串中必然會生成一個長度為K^(C-1)的區間，裡面都是G。

對於每個區間任選一個位置檢查即可， 總共檢查K次。

那麼對於S < K怎麼辦

還是一樣的方法，對於原始串的某個位置i，假設該處為G，那麼在最終串中最壞情況下，也會生成若干個G，這些G分佈在若干個長度不一的區間內。

例如K＝5， C＝3時

我們看每個位置生成G的情況。 由於串太長了。 我們先看最終串前25個

i=1,GGGGGGGGGGGGGGGGGGGGGGGGG

i=2,?G???GGGGG?G????G????G???

i=3,??G????G??GGGGG??G????G??

i=4,???G????G????G?GGGGG???G?

i=5,????G????G????G????GGGGGG

觀察這些我們發現，最多連續三個串，會在某一個位置都是G

例如i = 1,2,3時，第8個位置都是G，那麼我們檢查這個位置就同時檢查了3個位置。

而最多多少個串可以被同時檢查，可以發現取決於C，也就是同時C個串必然可以同時被檢查。

那麼最終最少的檢查次數就是 ceil(K * 1.0 / C)了

每個位置畫一畫就發現， 需要檢查的位置也很容易算出來了。

#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <cmath>
using namespace std;
int main() {
    int T, S, K, C,cas = 0;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d%d", &K, &C, &S);
        long long base = 1;
        for(int i = 0; i < C - 1; i++) {
            base = base * (long long)K;
        }
        int num = (int)(ceil(K * 1.0 / C));
        printf("Case #%d:", ++cas);
        if(num > S) {
            printf("  IMPOSSIBLE\n");
            continue;
        } 
        for(int i = 1; i <= num; i++) {
            int now = (i - 1) * C + 1;
            long long st = (long long)(now - 1) * base; 
            long long tmp = base;
            for(int j = 1; j < C; j++) {
                if(j + now > K) break;
                tmp /= K;
                st += tmp * (long long)(j + now - 1);
            }
            //long long mid = ed - base + 1 + 1;
            printf(" %lld", st + 1);
        }
        printf("\n");
    }
    return 0;
}