oj.uz

Submission #728079

# Submission time Handle Problem Language Result Execution time Memory
728079 2023-04-22T00:30:22 Z thomas_li Bowling (BOI15_bow) C++17
65 / 100
 1000 ms 13016 KB 
// yolo
#include <bits/stdc++.h>
using namespace std;
string rk = "x-"; vector<string> spstr,rgstr;
string c1 = "xxx";
vector<string> c2,c3,c4,c5,c6,c7;
int n,a[11]; int64_t dp[11][22][22][301]; // first i frames, carry amount from previous i, carry amount from i, score after i
                                          // carry is -1 if we don't add
string s;

void solve(){
    memset(dp,0,sizeof dp);
    cin >> n >> s; s = ' ' + s;
    for(int i = 1; i <= n; i++) cin >> a[i];
    auto can = [&](int i, string& t){
        assert(t.size() == 2);
        for(int j = 0; j < 2; j++){
            char c = s[i+j]; if(c == '?') continue;
            if(c != t[j]) return false;
        }
        return true;
    };
    auto can1 = [&](int i, string& t){
        assert(t.size() == 3);
        for(int j = 0; j < 3; j++){
            char c = s[i+j];
            if(c == '?') continue;
            if(c != t[j]) return false;
        }
        return true;
    };
    dp[0][0][0][0] = 1;
    auto add = [&](int64_t& x, int64_t y){
        x = (x+y);
    };
    // solve normal
    for(int i = 1; i <= n-1; i++){
        // generate good strings
        bool grk = can(2*i-1,rk);
        vector<string> gsp,grg;  
        for(auto& t : spstr) if(can(2*i-1,t)) gsp.push_back(t);
        for(auto& t : rgstr) if(can(2*i-1,t)) grg.push_back(t);
        swap(gsp,spstr);
        swap(grg,rgstr);
        for(int j = -1; j <= 10; j++) for(int k = -1; k <= 20; k++){ // previous previous, previous carries
            int lo = 0, hi = 270;
            if(a[i] != -1) lo = hi = a[i];           
            for(int l = lo; l <= hi; l++){ // cur score
                // strike
                // our shot needs to make j zero, k non negative
                if(grk && (j == -1 || j-10 == 0) && (k == -1 || (k-10 >= 0 && k-10 <= 10))){
                    // we can gain some more from carries if needed 
                    for(int gain = 0; gain <= 20; gain++){
                        if(l-gain-10 < 0) break;
                        int nk = (k == -1 ? -1 : k-10);
                        add(dp[i][nk+1][gain+1][l],dp[i-1][j+1][k+1][l-gain-10]);
                    }
                }     
                // spare
                for(auto& t : spstr){
                    // previous previous gets subtracted by fs, previous gets subtracted by 10
                    // both are gone after this frame, so need to become 0
                    int fs = t[0]-'0',sn = 10;
                    if(j != -1 && j-fs != 0) continue;
                    if(k != -1 && k-sn != 0) continue;
                    for(int gain = 0; gain <= 10; gain++){
                        if(l-gain-10 < 0) continue;
                        // add to previous slot to satisfy one bonus feature (in theory)
                        add(dp[i][gain+1][0][l],dp[i-1][j+1][k+1][l-gain-10]);
                    }
                }
                // regular
                for(auto& t : rgstr){
                    // previous previous gets subtracted by fs, previous gets subtracted by sn+fs
                    // both are gone after this frame, so need to become 0
                    int fs = t[0]-'0',sn = t[1]-'0';
                    if(j != -1 && j-fs != 0) continue;
                    if(k != -1 && k-fs-sn != 0) continue;
                    if(l-fs-sn < 0) continue;
                    add(dp[i][0][0][l],dp[i-1][j+1][k+1][l-fs-sn]);
                }
                /*
                bool good = 0;
                for(int z = 0; z <= 20 && !good; z++) for(int w = 0; w <= 20; w++) if(dp[i][z][w][l]){
                    good = 1;
                    break;
                }
                if(good) cout << l << " " << i << "\n";  */
            }
        }
        swap(gsp,spstr);
        swap(grg,rgstr);
    }
    // solve last
    // preprocess equalities
    vector<string> gc2,gc3,gc4,gc5,gc6,gc7;
    for(auto& t : c2) if(can1(2*n-1,t)) gc2.push_back(t);
    for(auto& t : c3) if(can1(2*n-1,t)) gc3.push_back(t);
    for(auto& t : c4) if(can1(2*n-1,t)) gc4.push_back(t);
    for(auto& t : c5) if(can1(2*n-1,t)) gc5.push_back(t);
    for(auto& t : c6) if(can1(2*n-1,t)) gc6.push_back(t);
    for(auto& t : c7) if(can1(2*n-1,t)) gc7.push_back(t);
    bool gc1 = can1(2*n-1,c1);
    swap(gc2,c2);
    swap(gc3,c3);
    swap(gc4,c4);
    swap(gc5,c5);
    swap(gc6,c6);
    swap(gc7,c7);
    int64_t ans = 0;
    for(int j = -1; j <= 10; j++) for(int k = -1; k <= 20; k++){ // previous previous, previous carries
        int lo = 0, hi = 300;
        if(a[n] != -1) lo = hi = a[n];
        for(int l = lo; l <= hi; l++){
            int64_t res = 0;
            // xxx 
            if(gc1 && (j == -1 || j-10 == 0) && (k == -1 || k-20 == 0) && l-30 >= 0){
                add(res,dp[n-1][j+1][k+1][l-30]);
            }
            // xxA  
            // condition is same since bonus is only contributed in the first two shots
            for(auto& t : c2){
                if(j != -1 && j-10 != 0) continue; 
                if(k != -1 && k-20 != 0) continue; 
                int ls = t[2]-'0'; 
                if(l-20-ls < 0) continue; 
                add(res,dp[n-1][j+1][k+1][l-20-ls]);
            }
            // xA/
            for(auto& t : c3){
                int fs = t[1]-'0',sn = 10-fs;
                if(j != -1 && j-10 != 0) continue; 
                if(k != -1 && k-10-fs != 0) continue; 
                if(l-20 < 0) continue;
                add(res,dp[n-1][j+1][k+1][l-20]);
            }
            // xAB
            for(auto& t : c4){
                int fs = t[1]-'0',sn = t[2]-'0';
                if(j != -1 && j-10 != 0) continue; 
                if(k != -1 && k-10-fs != 0) continue; 
                if(l-10-fs-sn < 0) continue;
                add(res,dp[n-1][j+1][k+1][l-10-fs-sn]);
            }
            // A/x
            for(auto& t : c5){
                int fs = t[0]-'0'; 
                if(j != -1 && j-fs != 0) continue;
                if(k != -1 && k-10 != 0) continue;
                if(l-20 < 0) continue;
                add(res,dp[n-1][j+1][k+1][l-20]);
            }
            // A/B
            for(auto& t : c6){
                int fs = t[0]-'0',ls = t[2]-'0'; 
                if(j != -1 && j-fs != 0) continue;
                if(k != -1 && k-10 != 0) continue;
                if(l-10-ls < 0) continue;
                add(res,dp[n-1][j+1][k+1][l-10-ls]);
            }
            // AB-
            for(auto& t : c7){
                int fs = t[0]-'0',sn = t[1]-'0'; 
                if(j != -1 && j-fs != 0) continue;
                if(k != -1 && k-fs-sn != 0) continue;
                if(l-fs-sn < 0) continue;
                add(res,dp[n-1][j+1][k+1][l-fs-sn]);
            }
            ans += res;
        }
    }
    swap(gc2,c2);
    swap(gc3,c3);
    swap(gc4,c4);
    swap(gc5,c5);
    swap(gc6,c6);
    swap(gc7,c7);
    cout << ans << "\n";
}
int main(){
    cin.tie(0)->sync_with_stdio(0);
    for(int i = 0; i <= 9; i++){
        spstr.push_back(to_string(i) + "/");
        c2.push_back("xx"+to_string(i));
        c3.push_back("x"+to_string(i)+"/");
        for(int j = 0; i+j < 10; j++){
            rgstr.push_back(to_string(i)+to_string(j));
            c4.push_back("x"+to_string(i)+to_string(j));
            c7.push_back(to_string(i)+to_string(j)+"-");
        }
        c5.push_back(to_string(i)+"/x");
        for(int j = 0; j <= 9; j++){
            c6.push_back(to_string(i)+"/"+to_string(j));
        }
    }
    int t; cin >> t; while(t--) solve();
}
// number of strs for frame: 10 + 1 + 10
// 5726805883325784576

Compilation message

bow.cpp: In function 'void solve()':
bow.cpp:131:35: warning: unused variable 'sn' [-Wunused-variable]
  131 |                 int fs = t[1]-'0',sn = 10-fs;
      |                                   ^~

Subtask #1
16.0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 159 ms 12884 KB Output is correct
2 Correct 127 ms 13016 KB Output is correct
3 Correct 38 ms 12884 KB Output is correct
4 Correct 40 ms 12884 KB Output is correct
5 Correct 40 ms 12892 KB Output is correct
6 Correct 38 ms 12928 KB Output is correct
7 Correct 183 ms 12884 KB Output is correct
8 Correct 232 ms 13000 KB Output is correct
9 Correct 183 ms 12884 KB Output is correct
10 Correct 179 ms 12884 KB Output is correct
11 Correct 132 ms 12872 KB Output is correct
12 Correct 203 ms 12892 KB Output is correct
13 Correct 45 ms 12892 KB Output is correct
14 Correct 196 ms 12888 KB Output is correct
15 Correct 45 ms 13012 KB Output is correct

Subtask #2
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 233 ms 12884 KB Output is correct
2 Correct 297 ms 12884 KB Output is correct
3 Correct 322 ms 12872 KB Output is correct
4 Correct 257 ms 12884 KB Output is correct
5 Correct 465 ms 12892 KB Output is correct
6 Correct 329 ms 12884 KB Output is correct
7 Correct 397 ms 12872 KB Output is correct
8 Correct 382 ms 12880 KB Output is correct
9 Correct 301 ms 12876 KB Output is correct
10 Correct 944 ms 12884 KB Output is correct
11 Correct 797 ms 12884 KB Output is correct
12 Correct 914 ms 12884 KB Output is correct
13 Correct 904 ms 12888 KB Output is correct
14 Correct 654 ms 12884 KB Output is correct
15 Correct 685 ms 12868 KB Output is correct
16 Correct 737 ms 12884 KB Output is correct
17 Correct 599 ms 12884 KB Output is correct
18 Correct 896 ms 13000 KB Output is correct
19 Correct 905 ms 13000 KB Output is correct
20 Correct 965 ms 12884 KB Output is correct
21 Execution timed out 1030 ms 12884 KB Time limit exceeded
22 Halted 0 ms 0 KB -

Subtask #3
26.0 / 26.0

# Verdict Execution time Memory Grader output
1 Correct 141 ms 12876 KB Output is correct
2 Correct 76 ms 12884 KB Output is correct
3 Correct 83 ms 12888 KB Output is correct
4 Correct 69 ms 12884 KB Output is correct
5 Correct 83 ms 12884 KB Output is correct
6 Correct 76 ms 12768 KB Output is correct
7 Correct 84 ms 12884 KB Output is correct
8 Correct 99 ms 12884 KB Output is correct
9 Correct 80 ms 12888 KB Output is correct
10 Correct 151 ms 12884 KB Output is correct
11 Correct 92 ms 12884 KB Output is correct
12 Correct 98 ms 12884 KB Output is correct
13 Correct 84 ms 12884 KB Output is correct
14 Correct 234 ms 12872 KB Output is correct
15 Correct 220 ms 12892 KB Output is correct
16 Correct 244 ms 13004 KB Output is correct
17 Correct 237 ms 12880 KB Output is correct
18 Correct 83 ms 12896 KB Output is correct
19 Correct 74 ms 12872 KB Output is correct
20 Correct 103 ms 12884 KB Output is correct
21 Correct 89 ms 12884 KB Output is correct

Subtask #4
23.0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 336 ms 12884 KB Output is correct
2 Correct 318 ms 12884 KB Output is correct
3 Correct 406 ms 12884 KB Output is correct
4 Correct 356 ms 12884 KB Output is correct
5 Correct 284 ms 12884 KB Output is correct
6 Correct 231 ms 12884 KB Output is correct
7 Correct 263 ms 12884 KB Output is correct
8 Correct 258 ms 12884 KB Output is correct
9 Correct 279 ms 12884 KB Output is correct
10 Correct 760 ms 12876 KB Output is correct
11 Correct 687 ms 12868 KB Output is correct
12 Correct 668 ms 12884 KB Output is correct
13 Correct 641 ms 12884 KB Output is correct
14 Correct 340 ms 12884 KB Output is correct
15 Correct 319 ms 12884 KB Output is correct
16 Correct 366 ms 12884 KB Output is correct
17 Correct 327 ms 12872 KB Output is correct
18 Correct 159 ms 12884 KB Output is correct
19 Correct 149 ms 12872 KB Output is correct
20 Correct 144 ms 12884 KB Output is correct
21 Correct 124 ms 12884 KB Output is correct

Subtask #5
0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 159 ms 12884 KB Output is correct
2 Correct 127 ms 13016 KB Output is correct
3 Correct 38 ms 12884 KB Output is correct
4 Correct 40 ms 12884 KB Output is correct
5 Correct 40 ms 12892 KB Output is correct
6 Correct 38 ms 12928 KB Output is correct
7 Correct 183 ms 12884 KB Output is correct
8 Correct 232 ms 13000 KB Output is correct
9 Correct 183 ms 12884 KB Output is correct
10 Correct 179 ms 12884 KB Output is correct
11 Correct 132 ms 12872 KB Output is correct
12 Correct 203 ms 12892 KB Output is correct
13 Correct 45 ms 12892 KB Output is correct
14 Correct 196 ms 12888 KB Output is correct
15 Correct 45 ms 13012 KB Output is correct
16 Correct 233 ms 12884 KB Output is correct
17 Correct 297 ms 12884 KB Output is correct
18 Correct 322 ms 12872 KB Output is correct
19 Correct 257 ms 12884 KB Output is correct
20 Correct 465 ms 12892 KB Output is correct
21 Correct 329 ms 12884 KB Output is correct
22 Correct 397 ms 12872 KB Output is correct
23 Correct 382 ms 12880 KB Output is correct
24 Correct 301 ms 12876 KB Output is correct
25 Correct 944 ms 12884 KB Output is correct
26 Correct 797 ms 12884 KB Output is correct
27 Correct 914 ms 12884 KB Output is correct
28 Correct 904 ms 12888 KB Output is correct
29 Correct 654 ms 12884 KB Output is correct
30 Correct 685 ms 12868 KB Output is correct
31 Correct 737 ms 12884 KB Output is correct
32 Correct 599 ms 12884 KB Output is correct
33 Correct 896 ms 13000 KB Output is correct
34 Correct 905 ms 13000 KB Output is correct
35 Correct 965 ms 12884 KB Output is correct
36 Execution timed out 1030 ms 12884 KB Time limit exceeded
37 Halted 0 ms 0 KB -