10.2シミュレーションゲームの概要

10.2シミュレーションゲームの概要

T1。

デジタルDP：

非常に非常に非常に非常に明確で、デジタルDP

\（[L、R] = [1、R] - [1、L-1] \）

これは、2を求めている数に等しい番組の一定数未満でした

\（F（I、J、 K）\） 演劇の低い数から\（Iは\）ビット、解答を計算するための規則に従っている\（J \クワッド（J = 0,1）\）

\（k個の\）のみバックの終了を検討することを示している\（LMT \）でのいくつかの大きさとの関係の背後にある\（= 0,1（K）\ ）

最初の検討\（I + 1 \）マグニチュードビット、デジタルカウントと新しい設定があると判定されると

注目\（L、R \）データが必要特に広範囲、高精度で、最終的な結果はバイナリで出力される、正確圧力を位置決めすることが可能です

（ステーキを超える問題への解決策）

この問題は、法律を見つけることを期待する普通の人です。

（1〜100）：次に、テーブルが演奏

その後なくなって（何？高精度はそれがあります）

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#define LL long long
using namespace std;
int n, q, v,  t, L, R, len;
char s[208];
struct bigint
{
    int len, zz;
    int v[1005];
    bigint(){len = 0; memset(v, 0, sizeof v); zz = 1;}
    bigint(int x)
    {
        if(x >= 0) zz = 1;
        else x = -x, zz = 0;
        len = 0;
        memset(v, 0, sizeof v);
        while(x)
        {
            v[ ++len] = x % 10;
            x /= 10;
        }
    }
    friend bool operator < (const bigint &a, const bigint &b)
    {
        if(a.len < b.len) return 1;
        if(a.len > b.len) return 0;
        for(int i = a.len ; i >= 1; i -- )
        {
            if(a.v[i] < b.v[i]) return 1;
            if(a.v[i] > b.v[i]) return 0;
        }
        return 0;
    }
    friend bool operator == (const bigint &a, const bigint &b)
    {
        if(a.len != b.len ) return 0;
        for(int i = a.len; i >= 1; i --)
        {
            if(a.v[i] != b.v[i]) return 0;
        }
        return 1;
    }
    friend bool operator <= (const bigint &a, const bigint &b)
    {
        if(a < b) return 1;
        else if(a == b) return 1;
        else return 0;
    }
    friend bool operator != (const bigint &a, const bigint &b)
    {
        if(a.len != b.len) return 1;
        for(int i = a.len; i >= 1; i --)
        {
            if(a.v[i] != b.v[i]) return 1;
        }
        return 0;
    }
}x, y, res;
bigint operator + (bigint a, bigint b)
{
    int len = a.len + b.len;
    bigint c;
    c.len = len;
    for(int i = 1; i <= len; i ++)
     c.v[i] = a.v[i] + b.v[i];
    for(int i = 1; i <= len; i ++)
    {
        if(c.v[i] >= 10)
        {
            ++c.v[i+1];
            c.v[i] -= 10;
        }
    }
    while(c.len&&!c.v[c.len]) c.len --;
    return c;
}
bigint operator - (bigint a, bigint b)
{
    int len = max(a.len, b.len);
    bigint c;
    for(int i = 1; i <= len; i ++)
    c.v[i] = a.v[i] - b.v[i];
    c.len = len;
    for(int i = 1; i <= c.len; i ++)
    {
        if(c.v[i] < 0)
        {
            c.v[i+1]--;
            c.v[i] += 10;
        }
    }
    while(c.len&&!c.v[c.len]) c.len --;
    return c;
}
bigint operator *(bigint a,bigint b)
{
    bigint c;
    for(int i = 1; i <= a.len; ++ i)
    for(int j = 1; j <= b.len; ++ j)
    c.v[i+j-1] += a.v[i] * b.v[j];
    c.len = a.len + b.len;
    for(int i = 1;  i <= c.len - 1; ++ i)
    {
        if(c.v[i] >= 10)
        {
            c.v[i+1] += c.v[i] / 10;
            c.v[i] %= 10;
        }
    }
    while(c.v[c.len] == 0&&c.len > 1) -- c.len;
    return c;
}
bigint operator /(bigint a,long long b)
{
    bigint c;int d = 0;
    for(int i = a.len; i >= 1; -- i)
    c.v[++ c.len] = ((d * 10 + a.v[i]) / b),d=(d*10+a.v[i])%b;
    for(int i=1;i<=c.len/2;++i)swap(c.v[i],c.v[c.len-i+1]);
    while(c.v[c.len]==0&&c.len>1)--c.len;
    return c;
}
bigint Min(bigint a, bigint b)
{
    if(a < b) return a;
    else return b;
}
bigint work(bigint x)
{
    if(x < bigint(4)) return bigint(1);
    bigint l = bigint(4), r = Min(x, bigint(7)), res = bigint(1);
    int opt = 1;
    for(; ; l = r + bigint(1), r = Min(r * bigint(2)  + bigint(1), x), opt ^= 1 )
    {
        if(opt)
          res = res + (r - l + bigint(1));
          if(r == x) break;
    }
    return res;
}
void out(bigint x)
{
    if(!x.len) return (void)printf("0");
    bigint qwq = bigint(1);
    while(qwq <= x) qwq = qwq * bigint(2);
    qwq = qwq / 2;
    for(; ; qwq = qwq /2)
    {
        if(qwq <= x)
        {
            printf("1");
            x = x - qwq;
        }
        else printf("0");
        if(qwq == bigint(1))break;
    }   
}
void solve()
{
    x = y = res = bigint(0);
    scanf("%s", s + 1);
    for(int i = 1; i <= n; i ++)
    {
        x = x * 2 + bigint(s[i] - '0');
    }
    scanf("%s", s + 1);
    for(int i = 1; i <= n; i ++)
    {
        y = y * 2 + bigint(s[i] - '0');
    }
    res = work(y) - work(x - bigint(1));
    if((n&1) == (q&1)) res = y - x + 1 - res;
    out(res);
    puts("");
}
signed main()
{
//  freopen("a.in", "r", stdin);
//  freopen("a.out", "w", stdout);
    scanf("%d", &t);
    while(t --)
    {
        scanf("%d%d",&n, &q);
        solve();
    }
    return 0;
}

T2

Sbの問題は、何もまとめません。。
。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#define LL long long
#define N 100005
using namespace std;
struct node
{
    int w1, w2, l1, l2;
}q[N];
int n, m, t, minw = 2e9, maxw = -233, minl = 2e9, maxl = -233, flag; 
signed main()
{
    freopen("b.in", "r",stdin);
    freopen("b.out", "w", stdout);
    scanf("%d", &t);
    while(t -- )
    {
        flag = 0; minw = minl = 2e9; maxw = maxl = -233;
        scanf("%d", &n);
        for(int i = 1; i <= n; i ++)
            scanf("%d%d%d%d", &q[i].w1, &q[i].w2, &q[i].l1, &q[i].l2);
        for(int i = 1; i <= n; i ++)
        {
            minw = min(minw, q[i].w1);
            maxw = max(maxw, q[i].w2);
            minl = min(minl, q[i].l1);
            maxl = max(maxl, q[i].l2);
        }
        for(int i = 1; i <= n; i ++)
        {
            if(q[i].w1 <= minw&&q[i].w2 >= maxw&&q[i].l1 <= minl&&q[i].l2 >= maxl)
            {flag = 1; break; }
        }
        if(flag)printf("TAK\n");
             else printf("NIE\n");
    }
    return 0;
}

T3

腫瘍トピックデータ構造の数+

- D、1与えられ、nは、すべての配列についてvが満たす（GCD（X、N）\を = D \） A \（X \） 、に\（[X] + = V \） 。

等価\（[X] + = V [GCD（X、N）== D] \）

そして、あなたは喜んで式をプッシュすることができます

（\ \ \ \ \ V [\ GCD（X、N）= D] \）

$ = V [\ GCD（\ FRAC {X} {D}の\ FRAC {n}が{D}）= 1] $

$ = Vの\和\ limits_ {K | \ GCD（\ FRAC {X} {D}の\ FRAC {n}が{D}）}ミュー\（K）$（毎日の反転）

$ = V \和\ limits_ {K | \ FRAC {X} {D}、K | \ FRAC {n}は{D}}ミュー\（K）$

\（= \和\ limits_ {K | \ FRAC {n}は{D}、KD | X}のV \ミュー（K）\）

暴力を列挙することは明らかにされ\（X \）のそれぞれについて、（\ {K | \ FRAC { n}は{D} \ X |及びKD}）と結合されている（のV \ミュー（K）\ \） 、

それは同等です

有効ため| \（\ {N-dfrac} {D} \ K） 、次いで\（X = KD、2KD、3KD ... \） 、列挙\（K \） 、全ての\（KD \）、プラス倍数である\（V \ MU（K）\） 。

このものの\（O（1）\）クエリが、変更の複雑さが大きすぎます

折半の複雑さを考えてみましょう

我々は、の配列開放\（Fの\）が全てであることを示している（iは\）\、複数の位置がプラスである（F [i]が\）\

変更だけ正当見つける必要が\（K \）を、次いで、\（F [KD] + = V \ MU（K）\） 、列挙除去\（KD \）の倍数と、

次に、クエリの数を照会します\（私は\）の時間、それはされるだろう（| \ sum_ {I D \ F（d）を\}）

\（X \）プレフィックス、およびです

\（\和\ limits_ {i = 1} ^ X \和\ limits_ {D | I} F（D）= \和\ limits_ {D = 1} ^ XF（D）\ lfloor \ FRAC {X} {D } \ rfloor \）

次いで、ブロックで分割することができ、取得する必要があるブロックの各ブロック\（F \）とは、シングルポイント・アレイは、ツリー加算間隔を維持することができる修飾されました。

時間複雑さの$ O（Qの\のSQRT {L} \ログL + Lの\ログL）$

Sahuaができ

そして、柿の理解

\（\和\ limits_ {i = 1} ^ X \和\ limits_ {D | I} 1 = \和\ limits_ {D = 1} ^ {X} \ lfloor \ FRAC {X} {D} \ rfloor \ ）

各番号へのすべての数値の数は約1×

列挙の除数に相当し、除数の倍数の数は、Xの数の倍数は、d未満である\（\ lfloorの\のFRAC {X} {D} \ rfloor \） 。