結果

問題 No.200 カードファイト！
ユーザー Kmcode1Kmcode1
提出日時 2015-04-29 00:40:37
言語 C++11
(gcc 11.4.0)
結果
WA  
実行時間 -
コード長 6,796 bytes
コンパイル時間 1,157 ms
コンパイル使用メモリ 113,748 KB
実行使用メモリ 5,376 KB
最終ジャッジ日時 2024-07-05 09:15:07
合計ジャッジ時間 2,082 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 WA -
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 WA -
testcase_20 WA -
testcase_21 WA -
testcase_22 WA -
testcase_23 WA -
testcase_24 AC 2 ms
5,376 KB
testcase_25 WA -
testcase_26 WA -
testcase_27 AC 2 ms
5,376 KB
testcase_28 WA -
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp: In function ‘int main()’:
main.cpp:217:10: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  217 |     scanf("%d", &n);
      |     ~~~~~^~~~~~~~~~
main.cpp:218:10: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  218 |     scanf("%d", &a);
      |     ~~~~~^~~~~~~~~~
main.cpp:221:14: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  221 |         scanf("%d", &k);
      |         ~~~~~^~~~~~~~~~
main.cpp:224:10: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  224 |     scanf("%d", &c);
      |     ~~~~~^~~~~~~~~~
main.cpp:227:14: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  227 |         scanf("%d", &k);
      |         ~~~~~^~~~~~~~~~

ソースコード

diff # 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cctype>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<sstream>
#include<fstream>
#include<iomanip>
#include<ctime>
#include<complex>
#include<functional>
#include<climits>
#include<cassert>
#include<iterator>
#include<valarray>
//#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
namespace math{
    long long int __gcd(long long int a, long long int b){
        if (a > b){
            swap(a, b);
        }
        while (a){
            swap(a, b);
            a %= b;
        }
        return b;
    }
    long long int lcm(long long int a, long long int b){
        long long int g = __gcd(a, b);
        a /= g;
        return a*b;
    }
    long long int ppow(long long int i, long long int j){
        long long int res = 1LL;
        while (j){
            if (j & 1LL){
                res *= i;
                res %= MOD;
            }
            i *= i;
            i %= MOD;
            j >>= 1LL;
        }
        return res;
    }
    namespace factorial{
        vector<long long int> lo;
        vector<double> l2;
        void set_long(long long int b){
            if (lo.size()){
            }
            else{
                lo.push_back(1);
            }
            for (long long int i = lo.size(); i <= b; i++){
                lo.push_back(lo.back());
                lo.back() *= i;
                if (lo.back() >= MOD){
                    lo.back() %= MOD;
                }
            }
        }
        void set_log(long long int b){
            if (l2.size()){
            }
            else{
                l2.push_back(log(0.0));
            }
            for (long long int i = l2.size(); i <= b; i++){
                l2.push_back(l2.back());
                l2.back() += log((double)(i));
            }
        }
        long long int get_long(int b){
            if (lo.size() <= b){
                set_long(b);
            }
            return lo[b];
        }
        double get_log(int b){
            if (l2.size() <= b){
                set_log(b);
            }
            return l2[b];
        }
    }
    namespace combination{
        long long int simpleC(long long int a, long long int b){
            if (a < b){
                return 0;
            }
            if (a - b < b){
                b = a - b;
            }
            long long int u = 1LL;
            for (long long int j = a; j >= a - b + 1LL; j--){
                u *= j;
                if (u >= MOD){
                    u %= MOD;
                }
            }
            long long int s = 1LL;
            for (long long int i = 1LL; i <= b; i++){
                s *= i;
                if (s >= MOD){
                    s %= MOD;
                }
            }
            return (u*ppow(s, MOD - 2)) % MOD;
        }
        long long int C(long long int a, long long int b){
            if (a < b){
                return 0;
            }
            long long int u = math::factorial::get_long(a);
            long long int s = math::factorial::get_long(b)*math::factorial::get_long(a - b);
            u %= MOD;
            s %= MOD;
            return (u*ppow(s, MOD - 2)) % MOD;
        }
        double logC(int a, int b){
            double u = math::factorial::get_log(a);
            double s = math::factorial::get_log(b) + math::factorial::get_log(a - b);
            return u - s;
        }
        long long int H(long long int a, long long int b){
            return math::combination::C(a + b - 1LL, b);
        }
        long long int simpleH(long long int a, long long int b){
            return math::combination::simpleC(a + b - 1LL, b);
        }
    }
    namespace prime{
        vector<long long int> prime;
        vector<long long int> use;  //smallest divisor
        void init(int b){
            use.assign(b + 1, 0);
            prime.clear();
            prime.push_back(2);
            use[2] = 2;
            for (int i = 3; i < use.size(); i += 2){
                if (use[i] == 0LL){
                    prime.push_back(i);
                    use[i] = i;
                    for (int j = i * 2; j < use.size(); j += i){
                        use[j] = i;
                    }
                }
            }
        }
        vector<int> factorizetion(long long int num){
            vector<int> r;
            r.clear();
            for (int i = 0; i<prime.size() && prime[i] * prime[i] <= num; i++){
                while (num%prime[i] == 0LL){
                    r.push_back(prime[i]);
                    num /= prime[i];
                }
            }
            if (num > 1LL){
                r.push_back(num);
            }
            return r;
        }
        int size_of_factorization(long long int num){
            int cnt = 0;
            for (int i = 0; i<prime.size() && prime[i] * prime[i] <= num; i++){
                while (num%prime[i] == 0LL){
                    cnt++;
                    num /= prime[i];
                }
            }
            if (num > 1LL){
                cnt++;
            }
            return cnt;
        }
        long long int number_of_div(long long int num){
            long long int way = 1LL;
            long long int cnt = 0;
            for (int i = 0; i < prime.size() && prime[i] * prime[i] <= num; i++){
                cnt = 0;
                while (num%prime[i] == 0){
                    cnt++;
                    num /= prime[i];
                }
                way *= (cnt + 1LL);
            }
            if (num > 1LL){
                way *= 2LL;
            }
            return way;
        }
    }
}

using namespace math;
int n;
int a;
int c;
vector<int> v;
vector<int> vv;
int main(){
    scanf("%d", &n);
    scanf("%d", &a);
    for (int i = 0; i < a; i++){
        int k;
        scanf("%d", &k);
        v.push_back(k);
    }
    scanf("%d", &c);
    for (int j = 0; j < c; j++){
        int k;
        scanf("%d", &k);
        vv.push_back(k);
    }
    sort(v.begin(), v.end());
    sort(vv.begin(), vv.end());
    vector<int> A = v;
    vector<int> B = vv;
    int countt = 0;
    while (n--){
        if (v.size() == 0){
            v = A;
        }
        if (vv.size() == 0){
            vv = B;
        }
        int nex = vv[0];
        int ind = upper_bound(v.begin(), v.end(), nex) - v.begin();
        if (ind == v.size()){
            ind = 0;
        }
        if (v[ind] > nex){
            countt++;
        }
        v.erase(ind + v.begin(), ind + 1 + v.begin());
        vv.erase(0 + vv.begin(), 1 + vv.begin());
    }
    printf("%d\n", countt+3);
    return 0;
}
0