ARC 046 B - 石取り大作戦

問題

問題概要

プレイヤーが交互に1個以上の石をとる. 最後に石をとったプレイヤーの勝利. 先手はA個まで, 後手はB個まで石をとることができる. 最適に行動したときどちらが勝利するか.

解法

まずN<=Aの時は先手がN個とって勝ち.
次に, 二人のプレイヤーが合計A+1をとることを考える. 先手がx(<=A)をとったなら, 後手はA+1-xをとるようにする. このような時, NがもしA+1の倍数なら, A+1-xをとるほうが必ず勝てる. これは後手が2人の合計を調整することで相手が石をとりきることができる, 自分が石をとりきることができる番を作っているから.
これを踏まえて, N<=A以外の場合だが, AとBが一致しているときとしていない時で場合分けができる.
一致しているとき, NがA+1の倍数なら合計A+1をとるように後手が調整できるのでBが勝つことができる. NがA+1の倍数でないとき, 一番はじめの手で先手がNがA+1の倍数になるように石の総数をちょうせいできるので, そのあとは後手が取った石の数に対して先手が石の数を調整していくことができるので, 先手が勝つことになる.
一致していないときで, A>Bのとき, 先手は1つ石をとった後, N-1>A-1>=Bとなるので,　後手の1ターン目では試合を終わらすことができず, そのあとは先手が後手のとった石の数から調整して残りの石がB+1の倍数残るようにしていけば, 勝つことができる(たぶん).
A<Bのときは, 後手が残りの石をA+1の倍数になるように調整していけば最後に後手が勝てるときがくる(たぶん).

ミス

ゲームは難しいね.

コード

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;

int main(void){
    int n, a, b; cin >> n >> a >> b;
    if(n <= a){
        printf("Takahashi\n");
    }else{
        if(a == b){
            // n = a + 1 なら必ず後手勝利. つまり, 先手が x を出したなら, 後手は a + 1 - x を出すようにすればいい.
            // 違うなら, 先手が上の状況を相手に与えられる.
            if(n % (a + 1) == 0) printf("Aoki\n");
            else printf("Takahashi\n");
        }else{
            // 多いほうが勝ち
            // 合計で a + 1 とるように選ぶのを 多いほうがやればいい.
            if(a > b) printf("Takahashi\n");
            else printf("Aoki\n");
        }
    }
    return 0;
}

SRM 600 div1 easy ORSolitaire

問題

問題概要

はじめはX=0でそこからnumbersとして与えられた数字の中の任意のものとORをとり, Xを更新して再びnumbersの中の任意のものとのORを繰り返していく. この処理をどのように繰り返してもgoalに行けなくなるようにするには, numbersからいくつの数値を取り除けばよいか. その最小値を求める問題.

解法

まず, goalのbitが立っていない桁のbitが立っている数値は使えないので, それらを考えないこととする.
あとは, goalのbitのなかで立っているなかの任意の桁のbitを1つ以上たたないようにすればよいので, numbersの中からそのbitが立っている数値を削除すればよいことになる. ではどのbitが立たないようにすれば最小になるかだが, 例えば
numbers{1, 2, 3, 4, 7, 8}, goal=7の場合を考える.
まず, 8は7で立っていないbitが立っているので無視.
001
010
011
100
111
numbersを順番に2進数で並べると上記のようになる. 7=(111)なので、0~2桁目のbitのうちのどれかが立たないようにすればよい. 例えば0bitが立たないようにするには1,3,7を削除, 1bitが立たないようにするには2,3,7を削除, 2bit目が立たないようにするには4,7を削除すればよい. よって今回は4,7を削除すれば最小数2で答えとなる. つまり, goalのbitが立っているibit目が立っているnumbersの数をcnt[i]としたら, cnt[i]の最小値が答えとなる.

ミス

bitset便利すぎ.

コード

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;

class ORSolitaire{
public:
    int cnt[55] = {0};
    int getMinimum(vector <int> numbers, int goal){
        bitset<50> g(goal);
        for(auto t : numbers){
            bitset<50> bi(t);
            bool flag = true;
            rep(i, bi.size()){
                if(bi[i] && !g[i]){ // goalに立っていないbitが立っているものは使えない
                    flag = false; break;
                }
            }
            if(!flag) continue;
            rep(i, bi.size()){
                if(bi[i]) cnt[i]++;
            }
        }
        int ret = INF;
        rep(i, g.size()){
            if(g[i]) chmin(ret, cnt[i]);
        }
        return ret;
    }
};

int main(void){
    ORSolitaire ors;
    printf("%d\n", ors.getMinimum({5,2,4,52,62,9,8,3,1,11,6}, 11));//3
    return 0;
}

SRM 546 div1 easy KleofasTail

問題

問題概要

xが偶数のとき　x / 2
xが奇数のとき x -= 1
ができる. [A, B]の数で上の操作を繰り返してKになるものの総数を求めよ.

解法

まず, 問題では小さくなる操作が与えられているが, 求めたいのはKになるかなので, Kから[A, B]の区間にいけるかを求めたほうがよさそうだということがわかる. 逆の操作の場合問題概要で示した操作は,
xが偶数のとき x = 2 (x <<= 1) または x += 1
xが奇数のとき　x = 2 (x <<= 1)
x(偶数)を2で割れば偶奇どちらもあり得るが, x(奇数)から1を引くときは偶数になるので, 逆の操作は上のようになる.
よって、Kから大きくしていくことを考えると, Kに対して2倍(K<<=1)と+1を繰り返して[A, B]の中に入るものの数をカウントすればよいことになる.
カウント方法はdfsで全探索をすれば簡単ではあるが, 今回は数が大きいので無理. そこでKから作られる数の特性を利用する.
Kが偶数のとき (Kのbit)(任意のbit)　または (K+1のbit)(任意のbit)
Kが奇数のとき (Kのbit)(任意のbit)
という数が作られることになるので, それを任意のbitの桁数ごとにいくつ範囲に入るかをカウントしてりけばいい. 任意のbitになるのは, +1と2倍(シフト)があれば作れるからだ. 例えば(Kのbit101)を作りたいなら, Kをシフトして+1して, さらに2回シフトして+1すれば作れる.
[A, B]の範囲に入るものをいきなり計算してもいいが, [0, A - 1], [0, B]をそれぞれ計算して,
[0, B] - [0, A - 1]で計算すれば実装が楽になる.

ミス

ぜんぜんわからなかった. Kから大きくしていく逆の操作でやるんだろうなということはわかっていたが, それ以上思いつかなった. ただ, Xが偶数の時に2で割ることは右へシフトさせたことと同じで, 奇数の時に-1をすることは最下位bitを0にすることと同じ. このような感覚を持ち, bitで考えようとすれば答えにたどり着けたかも. Kから全探索すればわかるわけだし, それをどう計算量を落とすかか.

コード

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;

class KleofasTail
{
public:
    //逆からたどる
    ll solve(ll k, ll x){ //[0, x)までの数で、途中で　k になるやつの数
        ll ret = 0;
        if(k % 2 == 0){//kが最下位bitが 0
            //そのままシフト
            for (ll i = 1; i * k < x; i *= 2){//[ k*2^i, k*2^(i+1) )　までが何個あるかをカウント
                ret += min(i, x - k * i); //x以上の部分をカウントしないようにする
            }
            //+1をした後にシフト
            for (ll i = 1; i * (k  + 1) < x; i *= 2){//[ k*2^i, k*2^(i+1) )　までが何個あるかをカウント
                ret += min(i, x - (k + 1) * i); //x以上の部分をカウントしないようにする
            }
        }else{
            //そんままシフト
            for (ll i = 1; i * k < x; i *= 2){//[ k*2^i, k*2^(i+1) )　までが何個あるかをカウント
                ret += min(i, x - k * i); //x以上の部分をカウントしないようにする
            }
        }
        return ret;
    }

    long long countGoodSequences(long long K, long long A, long long B){
        if(K == 0) return B - A + 1; // K==0 のときは上位bitが何も決まっていないじょうたいなので任意の数字を作ることができる.
        return solve(K, B + 1) - solve(K, A);
    }
};

int main(void){
    KleofasTail kt;
    // printf("%lld\n", kt.countGoodSequences(3, 4, 8)); // 2
    printf("%lld\n", kt.countGoodSequences(0, 0, 2));//3
    return 0;
}

SRM 661 div1 easy MissingLCM

問題

問題概要

lmc(1..M)=lcm(N+1,M)となる最小のMを求める.

解法

まず,
1,..,N,N+1,…,M
N+1,…,M
のlcmが一致することから,1…Nの中にlcmを作るのに寄与したものがいないので, 1…Nのなかに含まれる最大の素数の2倍の数がすくなくともMまでに含まれていなければならない. さらにM=2Nのとき, 1,..Nの数の倍数はすべて1,..Mの中に含まれるので, 必ず1,..Nがlcmに寄与しなくなるので, Mは最大でも2Nということになる. よってMの範囲は[(N以下で最大の素数), 2N]となる.
あとは,Mをその範囲で動かしながらlcm(1..M)とlcm(N+1,M)を高速に求めていけばよい.
範囲 lcmを求める計算量だが, 前処理を無視して範囲を[l,r]とすると, (r-l)logNとなり, おおよそO(N*logN)という結果になる. Mをインクリメントしていくが, その度に[l,r]のlcm(l,..r)を計算し直すとTLEしてしまう. なので、右端を1つ追加する感じでうまく処理する.

ミス

素因数分解を高速にやる方法がわからなかった. prime[i] := iが素数の場合には0, 以外のときはiを割りる最大の素数 となる配列を前処理で作っておくことで, 1つの数のlcm(素因数x^kのk)を求めるのがlognでできるようになる.

コード

AC

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;

class primelib{
public:
    vector<int> prime; //prime[i] := iが素数の場合には0, 以外のときはiを割りる最大の素数
    vector<int> memo; 
    primelib(int size):prime(size + 10, 0), memo(size + 10, 0){
        prime_factorization(size + 1);
    }
    //[left,right]までのlcmがmemo[x]:=xの次数 として表される
    void getlcm(int left, int right){
        // fill(memo.begin(), memo.end(), 0); //0で初期化
        for (int i = max(2, left); i <= right; ++i){
            map<int, int> degree; //<x, k> := x^k
            int tmp = i;
            while(prime[tmp]){
                degree[prime[tmp]]++;
                tmp /= prime[tmp]; //最大の素数で割る
            }
            degree[tmp]++; //残った素数をカウント
            //memo[x] := [left, right]までを素因数分解した最大のxの次数を更新
            for(auto u : degree){
                memo[u.first] = max(memo[u.first], u.second);
            }
        }
    }
private:
    //prime[i] := iが素数の場合には0, 以外のときはiを割りる最大の素数
    //これを使えばO(logn)で素因数分解可能
    void prime_factorization(int n){
        for (int i = 2; i <= n; i++) {
            if (prime[i] == 0) {
                for (int j = 2; j * i <= n; j++) {
                    prime[i * j] = i;
                }
            }
        }
    }
};

class MissingLCM
{
public:
    int getMin(int N){
        int ans;
        primelib pba(2 * N), pbb(2 * N);
        for (int i = N; i >= 1; --i){
            if(pba.prime[i] == 0){
                ans = i; break;
            }
        }
        //答えが[2 * ans, 2*N]の中
        pba.getlcm(N + 1, 2 * ans); pbb.getlcm(1, 2 * ans);
        int ret;
        for (int i = 2 * ans; i <= 2 * N; ++i){
            if(pba.memo == pbb.memo){//lcmが一致しているか
                ret = i;
                break;
            }
            //i+1を付け足す
            pba.getlcm(i + 1, i + 1); pbb.getlcm(i + 1, i + 1);
        }
        return ret;
    }
};

int main(void){
    MissingLCM lc;
    auto ret = lc.getMin(279841);
    printf("%d\n", ret);//559682
    return 0;
}

TLE

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;


class primelib{
public:
    vector<int> prime; //prime[i] := iが素数の場合には0, 以外のときはiを割りる最大の素数
    vector<int> memo; 
    primelib(int size):prime(size + 10, 0), memo(size + 10, 0){
        prime_factorization(size + 1);
    }
    //[left,right]までのlcmがmemo[x]:=xの次数 として表される
    void getlcm(int left, int right){
        fill(memo.begin(), memo.end(), 0); //0で初期化
        for (int i = max(2, left); i <= right; ++i){
            map<int, int> degree; //<x, k> := x^k
            int tmp = i;
            while(prime[tmp]){
                degree[prime[tmp]]++;
                tmp /= prime[tmp]; //最大の素数で割る
            }
            degree[tmp]++; //残った素数をカウント
            //memo[x] := [left, right]までを素因数分解した最大のxの次数を更新
            for(auto u : degree){
                memo[u.first] = max(memo[u.first], u.second);
            }
        }
    }
private:
    //prime[i] := iが素数の場合には0, 以外のときはiを割りる最大の素数
    //これを使えばO(logn)で素因数分解可能
    void prime_factorization(int n){
        for (int i = 2; i <= n; i++) {
            if (prime[i] == 0) {
                for (int j = 2; j * i <= n; j++) {
                    prime[i * j] = i;
                }
            }
        }
    }
};

class MissingLCM
{
public:
    int getMin(int N){
        int ans;
        primelib pba(2 * N), pbb(2 * N);
        for (int i = N; i >= 1; --i){
            if(pba.prime[i] == 0){
                ans = i; break;
            }
        }
        printf("%d\n", ans * 2);
        //答えが[2 * ans, 2*N]の中
        int ret;
        for (int i = 2 * ans; i <= 2 * N; ++i){
            pba.getlcm(N + 1, i); pbb.getlcm(1, i);
            if(pba.memo == pbb.memo){//lcmが一致しているか
                ret = i;
                break;
            }
        }
        return ret;
    }
};

/* TLE */
int main(void){
    MissingLCM lc;
    auto ret = lc.getMin(279841);
    printf("%d\n", ret);//559682
    return 0;
}

SRM 662 div1 easy FoxesOfTheRoundTable

問題

問題概要

きつねの身長があたえられる. 円形に並べらた時, 隣あうきつねの身長差の絶対値の最大値Dとして, Dの最小値を求める.

解法

貪欲法でとけるみたい. 偶数番目を左側, 奇数番目を右側にして, 左側を昇順, 右側を降順にしてやればいいみたい. なんでこれでいいのかわからないので復習.

ミス

よくわからない. 高さが山のような形になればいいことがわかったんだけど, 左の山と右の山にどうわけるのかわからなかった. 2ⁿ試さないと無理だなーという感じ.

コード

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;

class FoxesOfTheRoundTable{
public:
    vector <int> minimalDifference(vector <int> h){
        vector<pair<int, int> > v;
        rep(i, h.size()){
            v.pb(mp(h[i], i));
        }
        sort(all(v));
        vector<int> l, r;
        rep(i, v.size()){
            if(i % 2 == 0) l.pb(v[i].se);
            else r.pb(v[i].se);
        }
        reverse(all(r));
        l.insert(l.end(), all(r));
        return l;
    }
};

int main(void){
    FoxesOfTheRoundTable ft;
    auto ret = ft.minimalDifference({1,99,50,50});
    for(auto u : ret){
        printf("%d ", u);
    }
    printf("\n");
    return 0;
}

SRM 666 div1 easy WalkOverATree

問題

問題概要

木構造の情報が与えられる.　すべての辺のコストを1として, コストLいないで通ることができる頂点の種類数の最大値を求める問題. ただしstart地点を0として, start,goal も通った頂点としてカウントする.

解法

一番の方針として, 頂点を巡ったあとに同じ頂点を通った戻ってくるのは無駄なので, 一番最後は行くだけ行って戻ってこないというのが考えられる. また, 1つの頂点を通るためには2回パスを通る必要があることがわかる.
これからの考察から, 任意の頂点i を最後にいくだけいく頂点として, 残りのステップ回数でほかの頂点を1つ訪れるのに2ステップ使って訪れればよい. つまり, 最後以外は2ステップで1つの頂点を訪れ, 最後だけd[i]ステップでd[i]個の頂点を巡ればいい.
実装はステップ回数が足りない時の処理や, 実際の頂点数より多く巡ったことにしないように気を付けて実装すればいい.

ミス

問題文読んでないから, For each i, parent[i] will be between 0 and i, inclusive.
を見逃して、iを順番に見ていけばトポロジカルソートされていているので, DAG上を走査するだけですべての頂点の深さを求められることに気が付かなかった. まあ, 普通にグラフの連結リストを作った後にdfsで深さ求めるだけでいいんだが. 木の上のdpなんかはそのままではDAGの順番がわからないからdfsでよくやるしね. 今回はありがたいことにトポロジカルソートした結果が与えられていた感じ.

コード

トポロジカルソートされているのを利用して, dpで深さを計算

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;

class WalkOverATree{
public:
    int d[55];

    int maxNodesVisited(vector <int> parent, int L){
        int n = parent.size() + 1;
        //木構造をトポロジカルソートされている順番で並べられているので、DAG上をたどるだけでできる. 
        //For each i, parent[i] will be between 0 and i, inclusive.
        //上のような制約が書かれているので、ループで回していくだけok 
        //グラフの隣接リストを形成して、それで再帰関数で深さを求めるのもok
        d[0] = 0;
        int ret = 0;
        for (int i = 0; i < n - 1; ++i){
            d[i + 1] = d[parent[i]] + 1;
        }

        for (int i = 1; i <= n; ++i){
            int ans = 1, nokoriL = L, nokorin = n - 1;
            // printf("ans %d noL %d nn %d\n", ans, nokoriL, nokorin);
            if(d[i] <= L){
                ans += d[i]; // 最後に行きだけで稼ぐ分
                nokoriL -= d[i];
                nokorin -= d[i];
            }
            // printf("%d %d %d %d\n", d[i], ans, nokoriL, nokorin);
            ans += min(nokorin, nokoriL / 2); //　残りは1つ得るのに、行き帰りが必要
            chmax(ret, ans);
        }
        return ret;
    }
};

int main(void){
    WalkOverATree wa;
    // auto d = wa.maxNodesVisited({0, 0}, 2);
    auto d = wa.maxNodesVisited({0,0,0,0,2,4,2,3,1},1);
    printf("%d\n", d);
    return 0;
}

グラフを作ってdfsで深さを計算

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;

class WalkOverATree{
public:
    int d[55];
    vector<int> G[55];
    //グラフの隣接リストを形成して、それで再帰関数で深さを求めるのもok
    void dfs(int u, int p){
        if(p != -1) d[u] = d[p] + 1;
        for(auto v : G[u]){
            if(v == p) continue;
            dfs(v, u);
        }
    }
    int maxNodesVisited(vector <int> parent, int L){
        int n = parent.size() + 1;
        rep(i, parent.size()){
            G[parent[i]].pb(i + 1);
            G[i + 1].pb(parent[i]);
        }
        d[0] = 0;
        dfs(0, -1);
        int ret = 0;
        for (int i = 1; i <= n; ++i){
            int ans = 1, nokoriL = L, nokorin = n - 1;
            // printf("ans %d noL %d nn %d\n", ans, nokoriL, nokorin);
            if(d[i] <= L){
                ans += d[i]; // 最後に行きだけで稼ぐ分
                nokoriL -= d[i];
                nokorin -= d[i];
            }
            // printf("%d %d %d %d\n", d[i], ans, nokoriL, nokorin);
            ans += min(nokorin, nokoriL / 2); //　残りは1つ得るのに、行き帰りが必要
            chmax(ret, ans);
        }
        return ret;
    }
};

int main(void){
    WalkOverATree wa;
    // auto d = wa.maxNodesVisited({0, 0}, 2);
    auto d = wa.maxNodesVisited({0,0,0,0,2,4,2,3,1},1);
    printf("%d\n", d);
    return 0;
}

yukicoder No.483 マッチ並べ

問題

問題概要

指定された場所にマッチを置く. マッチの置き方は上下の2通りの選択肢がある. 置き方を工夫して, 頭薬の部分が重ならないようにおけるかを判断せよ.

解法

単純にやるには, すべてのマッチ棒を上下試してやればいいが, 2ⁿかかるため無理. そこで, すべてのマッチ棒の組み合わせについて考えて, 論理式を作り、それを解けばよいことがわかる. よって, 2SAT(2-SAT)でやればいい.

ミス

こないだ2SATやっといてよかった.

コード

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;

class strongly_connected_components{
public:
    int group_cnt; // sccの数
    vector<vector<int> > G, rG;
    vector<int> used, vs;
    vector<int> cmp; //cmp[v] := 頂点vが含まれる連結成分がどれなのかを示す番号
    strongly_connected_components(const vector<vector<int> > &g, const vector<vector<int> > &rg, int n): 
        G(g), rG(rg), cmp(2 * n), used(2 * n){
        //mainの処理
        fill(used.begin(), used.end(), 0);
        for (int i = 0; i < G.size(); ++i){
            if(!used[i]) dfs(i);
        }
        fill(used.begin(), used.end(), 0);
        int k = 0;
        for (int i = vs.size() - 1; i >= 0; --i){
            if(!used[vs[i]]) rdfs(vs[i], k++);
        }
        group_cnt = k;
    }
    int operator[](int i){//連結成分の番号を返す
        return cmp[i];
    }
private:
    void dfs(int curr){
        used[curr] = true;
        for(auto next : G[curr]){
            if(!used[next]) dfs(next);
        }
        vs.push_back(curr);
    }
    void rdfs(int curr, int k){
        used[curr] = true;
        cmp[curr] = k;//頂点vに対して、k番目と強連結成分であること入れる
        for(auto next : rG[curr]){
            if(!used[next]) rdfs(next, k);
        }
    }
};

class twosatisfiability{
public:
    int V;
    vector<int> res; // 1:= 0:=
    vector<vector<int> > g, rg;
    twosatisfiability(int n) : V(n), g(2 * n), rg(2 * n), res(n){}

    bool exec() {
        strongly_connected_components scc(g, rg, V);
        for (int i = 0; i < V; i++) {
            if (scc[i] == scc[i + V]) return false;
            res[i] = scc[i] > scc[i + V];
        }
        return true;
    }
    void add_edge(int a, int b){
        g[a].push_back(b);
        rg[b].push_back(a);
    }
    //0~V-1: x_i
    //V~2V-1: notx_i
    void add(int a, bool apos, int b, bool bpos){//a V b をグラフへ
        add_edge(a + (apos ? V : 0), b + (bpos ? 0 : V)); // not a -> b
        add_edge(b + (bpos ? V : 0), a + (apos ? 0 : V)); // not b -> a
    }
    bool operator[](int k){
        return res[k];
    }
};

int n;
int r0[110], c0[110], r1[110], c1[110];
int main(void){
    cin >> n;
    rep(i, n){
        cin >> r0[i] >> c0[i] >> r1[i] >> c1[i];
    }
    twosatisfiability sat(n);

    rep(i, n){
        reps(j, i + 1, n){
            //そのままで一致するとき、true
            //被りが生じるような組み合わせには偽となるような節を追加
            //かぶさる可能性のあるものを反転させたものをグラフに追加する
            if (r1[i] == r1[j] && c1[i] == c1[j]){// false false
                sat.add(i, true, j, true);
            }
            if (r1[i] == r0[j] && c1[i] == c0[j]) {//false true
                sat.add(i, true, j, false);
            }
            if (r0[i] == r1[j] && c0[i] == c1[j]) {//true false
                sat.add(i, false, j, true);
            }
            if (r0[i] == r0[j] && c0[i] == c0[j]) {//true true
                sat.add(i, false, j, false);
            }
        }
    }

    bool flag = sat.exec();
    if(flag){
        printf("YES\n");
    }else{
        printf("NO\n");
    }
    return 0;
}