2. 程式人生 > 其它 >NOIP提高組模擬賽24[matrix block graph]

NOIP提高組模擬賽24[matrix block graph]

阿新 • • 發佈：2022-05-10

T1. 大力狀壓。沒了

#include <cstdio>
#include <cstring>
#include <cctype>
#include <iostream>
#include <sstream>
#include <stack>
#include <cmath>
#include <algorithm>
#include <map>
#include <deque>
#include <bitset>
#include <list>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int read()
{
    int x = 0;
    char c;
    bool f = 0;
    while (!isdigit(c = getchar()))
    {
        if (c == '-')
        {
            f = 1;
        }
    }
    do
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
    } while (isdigit(c = getchar()));
    if (f)
    {
        return -x;
    }
    return x;
}

const int maxn = 12, maxk = 1030;

int n, m, MAX;

char str[maxn];
int p[maxn][maxn];
int a[maxn];
int f[maxn][maxk][maxk], g[maxn][maxk], las[maxn][maxk];

int main()
{
    #ifndef DEBUG
    freopen("matrix.in", "r", stdin);
    freopen("matrix.out", "w", stdout);
    #endif
    n = read(), m = read();
    for (int i = 1; i <= n; ++i)
    {
        scanf("%s", str);
        for (int j = 0; j < m; ++j)
        {
            a[i] |= ((str[j] - '0') << j);
        }
    }
    int MAX = 1 << m;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            p[i][j] = read();
        }
        for (int j = 0; j < MAX; ++j)
        {
            int tmp = 0;
            for (int k = 0; k < m; ++k)
            {
                if (j & (1 << k))
                {
                    tmp += p[i][k];
                }
            }
            g[i][j] = tmp;
        }
    }
    memset(f, 0x3f, sizeof f);
    for (int i = 0; i < MAX; ++i)
    {
        for (int j = 0; j < MAX; ++j)
        {
            f[0][i][j] = 0;
        }
    }
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < MAX; ++j)
        {
            for (int u = 0; u < MAX; ++u)
            {
                if ((j | u) != MAX - 1)
                {
                    continue;
                }
                for (int k = 0; k < MAX; ++k)
                {
                    if (f[i][j][k] == 0x3f3f3f3f)
                    {
                        continue;
                    }
                    int tmp = u | ((u << 1) & (MAX - 1)) | (u >> 1) | k | a[i + 1];
                    if (i == 0)
                    {
                        tmp = u | ((u << 1) & (MAX - 1)) | (u >> 1) | a[i + 1];
                    }
                    f[i + 1][tmp][u] = min(f[i + 1][tmp][u], f[i][j][k] + g[i + 1][u]);
                }
            }
        }
    }
	int ans = 0x7fffffff;
    for (int i = 0; i < MAX; ++i)
    {
        ans = min(ans, f[n][MAX - 1][i]);
    }
    printf("%d\n", ans);
}

T2. 第一問簡單題排個序就完了，第二問線段樹維護 （這兩問一點關係沒有……）

#include <cstdio>
#include <cstring>
#include <cctype>
#include <iostream>
#include <stack>
#include <cmath>
#include <algorithm>
#include <map>
#include <queue>
#include <deque>
#include <bitset>
#include <list>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int read()
{
    int x = 0;
    char c;
    bool f = 0;
    while (!isdigit(c = getchar()))
    {
        if (c == '-')
        {
            f = 1;
        }
    }
    do
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
    } while (isdigit(c = getchar()));
    if (f)
    {
        return -x;
    }
    return x;
}

const int maxn = 5e5 + 10, mod = 1e9 + 7;

int n;

struct data
{
    int key, val;
} a[maxn];

bool cmp(const data &a, const data &b)
{
    if (a.val == b.val)
    {
        return a.key < b.key;
    }
    return a.val > b.val;
}

bool cmp2(const data &a, const data &b)
{
    if (a.val == b.val)
    {
        return a.key < b.key;
    }
    return a.val < b.val;
}

struct SegmentTree
{
    #define ls (p << 1)
    #define rs ((p << 1) | 1)
    struct data
    {
        int val, key, now, from;
        int lazy, mn;
    } tr[maxn << 2];
    int mim(int x, int y)
    {
        if (x == -1)
        {
            return y;
        }
        if (y == -1)
        {
            return x;
        }
        if (a[x].key != a[y].key)
        {
            return a[x].key < a[y].key ? x : y;
        }
        return a[x].val < a[y].val ? x : y;
    }
    void PushUp(int p)
    {
        if (tr[ls].now <= tr[rs].now)
        {
            tr[p].now = tr[ls].now;
            tr[p].from = tr[ls].from;
        }
        else
        {
            tr[p].now = tr[rs].now;
            tr[p].from = tr[rs].from;
        }
        tr[p].mn = mim(tr[ls].mn, tr[rs].mn);
    }
    void PushDown(int p)
    {
        if (!tr[p].lazy)
        {
            return;
        }
        tr[ls].lazy += tr[p].lazy;
        tr[rs].lazy += tr[p].lazy;
        tr[ls].now += tr[p].lazy;
        tr[rs].now += tr[p].lazy;
        tr[p].lazy = 0;
    }
    void Build(int p, int l, int r)
    {
        if (l == r)
        {
            tr[p].val = a[l].val;
            tr[p].now = tr[p].key = a[l].key;
            tr[p].from = l;
            tr[p].mn = l;
            return;
        }
        int mid = (l + r) >> 1;
        Build(ls, l, mid);
        Build(rs, mid + 1, r);
        PushUp(p);
    }
    void Modify(int p, int l, int r, int pos)
    {
        if (l == r)
        {
            tr[p].key = 0x3f3f3f3f;
            tr[p].now = 0x3f3f3f3f;
            tr[p].mn = -1;
            return;
        }
        PushDown(p);
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            Modify(ls, l, mid, pos);
        }
        else
        {
            Modify(rs, mid + 1, r, pos);
        }
        PushUp(p);
    }
    void Modify(int p, int l, int r, int L, int R)
    {
        if (L > R)
        {
            return;
        }
        if (L <= l && r <= R)
        {
            --tr[p].lazy;
            --tr[p].now;
            return;
        }
        PushDown(p);
        int mid = (l + r) >> 1;
        if (L <= mid)
        {
            Modify(ls, l, mid, L, R);
        }
        if (R > mid)
        {
            Modify(rs, mid + 1, r, L, R);
        }
        PushUp(p);
    }
    int Query(int p, int l, int r, int L, int R)
    {
        if (L > R)
        {
            return -1;
        }
        if (L <= l && r <= R)
        {
            return tr[p].mn;
        }
        PushDown(p);
        int mid = (l + r) >> 1, ans = -1;
        if (L <= mid)
        {
            ans = mim(ans, Query(ls, l, mid, L, R));
        }
        if (R > mid)
        {
            ans = mim(ans, Query(rs, mid + 1, r, L, R));
        }
        PushUp(p);
        return ans;
    }
} T;

int pre[maxn], nxt[maxn];

int main()
{
    #ifndef DEBUG
    freopen("block.in", "r", stdin);
    freopen("block.out", "w", stdout);
    #endif
    n = read();
    for (int i = 1; i <= n; ++i)
    {
        a[i].key = read();
        a[i].val = read();
    }
    sort(a + 1, a + n + 1, cmp);
    ll ans = 1;
    int tot = 1;
    for (int i = 1; i <= n; ++i)
    {
        if (a[i].val == a[i - 1].val)
        {
            ans = ans * min(i, a[i].key + tot) % mod;
            ++tot;
        }
        else
        {
            ans = ans * min(i, a[i].key) % mod;
            tot = 1;
        }
    }
    printf("%lld\n", ans);
    sort(a + 1, a + n + 1, cmp2);
    for (int i = 1; i <= n; ++i)
    {
        if (a[i].val == a[i - 1].val)
        {
            pre[i] = pre[i - 1];
        }
        else
        {
            pre[i] = i - 1;
            nxt[i - 1] = i;
        }
    }
    for (int i = n; i; --i)
    {
        if (!nxt[i])
        {
            nxt[i] = nxt[i + 1];
        }
    }
    nxt[n] = n;
    T.Build(1, 1, n);
    for (int i = 1; i <= n; ++i)
    {
        int tmp;
        if (T.tr[1].now == 1)
        {
            tmp = T.Query(1, 1, n, 1, nxt[T.tr[1].from]);
        }
        else
        {
            tmp = T.tr[1].mn;
        }
        printf("%d %d\n", a[tmp].key, a[tmp].val);
        T.Modify(1, 1, n, tmp);
        T.Modify(1, 1, n, 1, pre[tmp]);
    }
}

T3. 隨機化即可（霧）

#include <cstdio>
#include <cstring>
#include <cctype>
#include <iostream>
#include <sstream>
#include <stack>
#include <cmath>
#include <algorithm>
#include <map>
#include <deque>
#include <queue>
#include <bitset>
#include <list>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int read()
{
    int x = 0;
    char c;
    bool f = 0;
    while (!isdigit(c = getchar()))
    {
        if (c == '-')
        {
            f = 1;
        }
    }
    do
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
    } while (isdigit(c = getchar()));
    if (f)
    {
        return -x;
    }
    return x;
}

const int maxn = 1e3 + 10, maxe = 2e3 + 10;

struct Graph
{
    int head[maxn], len;
    int nxt[maxe << 1], to[maxe << 1], dis[maxe << 1];
    void Ins(int u, int v, int d)
    {
        to[++len] = v;
        nxt[len] = head[u];
        dis[len] = d;
        head[u] = len;
    }
} G;

int n, m, tot;

ull dis1[maxn], disn[maxn];
bool vis[maxn];

struct data
{
    ull dis;
    int u;
    data(ull a, int b)
    {
        dis = a;
        u = b;
    }
    bool operator < (const data &b) const
    {
        return dis > b.dis;
    }
};

ull x;

void Dijkstra(int s, ull *dis)
{
    priority_queue<data> q;
    memset(vis, 0, sizeof vis);
    dis[s] = 0;
    q.push(data(0, s));
    while (!q.empty())
    {
        int u = q.top().u;
        q.pop();
        if (vis[u])
        {
            continue;
        }
        vis[u] = 1;
        for (int i = G.head[u]; i; i = G.nxt[i])
        {
            int v = G.to[i];
            if (G.dis[i] == -1)
            {
                if (dis[v] > dis[u] + x)
                {
                    dis[v] = dis[u] + x;
                    q.push(data(dis[v], v));
                }
            }
            else
            {
                if (dis[v] > dis[u] + G.dis[i])
                {
                    dis[v] = dis[u] + G.dis[i];
                    q.push(data(dis[v], v));
                }
            }
        }
    }
}

bool ok[maxn];

ull rand(ull l, ull r)
{
    return 1ull * rand() * rand() % (r - l + 1) + l;
}

void Test()
{
    memset(dis1, 0x3f, sizeof dis1);
    memset(disn, 0x3f, sizeof disn);
    Dijkstra(1, dis1);
    Dijkstra(n, disn);
    for (int i = 1; i <= n; ++i)
    {
        if (dis1[i] + disn[i] == dis1[n])
        {
            ok[i] = 1;
        }
    }
}

int main()
{
    srand(time(0));
    #ifndef DEBUG
    freopen("graph.in", "r", stdin);
    freopen("graph.out", "w", stdout);
    #endif
    n = read(), m = read();
    ull MAX = 0;
    for (int i = 1; i <= m; ++i)
    {
        int u = read(), v = read(), d = read();
        if (d == -1)
        {
            ++tot;
        }
        if (d != -1)
        {
            MAX = max(MAX, 1ull * d);
        }
        G.Ins(u, v, d);
        G.Ins(v, u, d);
    }
    if (n < 1000) 
    {
        for (x = 0; x <= 100000; x += 4)
        {
            Test();
        }
    }
    else 
    { 
        x = 0;
        Test();
        for (ull l = 1; l <= 1e6; l += 1e4)
        {
            for (int j = 1; j <= 5; ++j)
            {
                x = rand(l, l + 1e4 - 1);
                Test();
            }
        }
        for (ull l = 1e6; l <= MAX; l += 1e7)
        {
            for (int j = 1; j <= 5; ++j)
            {
                x = rand(l, l + 1e7 - 1);
                Test();
            }
        }
        x = 1e14;
        Test();
    }
    for (int i = 1; i <= n; ++i)
    {
        if (ok[i])
        {
            putchar('1');
        }
        else
        {
            putchar('0');
        }
    }
    putchar('\n');
}

相關推薦

NOIP提高組模擬賽24[matrix block graph]

T1. 大力狀壓。沒了 #include <cstdio> #include <cstring> #include <cctype> #include <iostream>

NOIP提高組模擬賽4

A. 入陣曲 丹青千秋釀，一醉解愁腸。 無悔少年枉，只願壯志狂。 矩陣字首和加暴力\\(O(N^2M^2)\\) 60pts有手就行

NOIP提高組模擬賽15

A. 計數題 以每個位置結尾的字串最多隻有一個，對於一個串，如果擴充套件他的字首，不會使結果變差，那麼我們就強制取以1位置開始的子序列，發現如果產生了衝突，那麼一定是一個字首和一個子串的字尾相同，那麼這個

NOIP提高組模擬賽20

A. 星際旅行 乍一看好像挺難，考場上跳過做後面，回來一想也不是多難 大膽猜測結論，然後居然證出來了，然而沒有開\\(longlong\\)我直接爆炸

NOIP提高組模擬賽夜間版2

沒想到這個系列還能再更新 A. 裝飾 這種題就需要大膽猜測打表驗證 反正就是推出來了，式子變化一下就是題解式子，就是有億點不簡潔

NOIP提高組模擬賽21

夜鶯與玫瑰 想了大概\\(2h\\)也沒搞出來，真的是。。。我太菜了 最後連\\(60pts\\)暴力都沒調出來（式子沒有\\(max\\)），還是時間分配不合理，留給打爆力的時間太少了。。。。。。。（最後\\(10min\\)能打出來才是奇

NOIP提高組模擬賽加1

A. 哪一天她能重回我身邊 學網路瘤學傻了，用費用瘤搞掉第一問就在想怎麼搞方案，然後越想越偏。。。。。

NOIP提高組模擬賽加2

又雙叒叕考炸了。。。 A. 光 我好像也被叫做光來著 這題，怎麼說呢，不能說噁心，只能說非常噁心。

2020-08-08 提高組模擬賽選講

Problem T2. 作業 考慮狀壓 DP \\(f[mask]\\) 表示當前已經排好序的顏色狀態為 \\(mask\\)，最少的交換次數。

2020-08-09 提高組模擬賽選講

Problem T1. 雷神領域 生成新的點的性質是兩個座標都已經配對過，也就是在同一個連通塊中。

「0825提高組模擬賽」

「0825提高組模擬賽」 「T1」 考場上沒什麼思路。。。 首先，不需要知道每一次操作的 \\(b\\) 具體是什麼數，只要關心相對大小就行

【計蒜客7月提高組模擬賽B】劍鬼

\\(\\texttt{計蒜客7月提高組模擬賽 } \\text{劍鬼}\\)​ 定義兩棵二叉樹相同，當且僅當：

「NOIP普及組模擬賽20180519」旅遊

link 思維題。 乍一看像一個樹剖的套路題，但又感覺做不了。原因是尋常的樹剖是 \\(x\\) 向上走，\\(y\\) 向上走，然後求交集。但是這裡是求不相交的部分。往上跑直接加貢獻是走不了的。原因是相交的部分不能要。

2020.09.12【NOIP提高組&普及組】模擬賽C組2

總結：這次比賽成績並不理想，雖然策略得當 各題題解和改題情況 T1 匹配 題面

2020.09.05【NOIP提高組&普及組】模擬賽C組1總結

今天比賽考的灰常不好，主要原因還是策略問題 T1 【NOIP2010TG】機器翻譯 題目大意

2020.07.15【NOIP提高組】模擬

2020.07.15比賽總結 最大配對 題目大意：給出\\(2\\)個序列\\(A={a[1]，a[2]，…，a[n]}，B={b[1]，b[2]，…，b[n]}\\)，從\\(A、B\\)中各選出k個元素進行一一配對（可以不按照原來在序列中的順序），並使得所有配對

紀中暑假集訓 2020.08.07【NOIP提高組】模擬 T1：【佛山市選2013】迴文子序列

【佛山市選2013】迴文子序列 Description 迴文序列是指左右對稱的序列。例如1 2 3 2 1是迴文序列，但是1 2 3 2 2就不是。我們會給定一個N×M的矩陣，你需要從這個矩陣中找出一個P×P的子矩陣，使得這個子矩陣的每一列

紀中暑假集訓 2020.08.07【NOIP提高組】模擬 T2：【佛山市選2013】樹環轉換

【佛山市選2013】樹環轉換 Description 給定一棵N個節點的樹，去掉這棵樹的一條邊需要消耗值1，為這個圖的兩個點加上一條邊也需要消耗值1。樹的節點編號從1開始。在這個問題中，你需要使用最小的消耗值（加邊和刪邊操

紀中暑假集訓 2020.08.07【NOIP提高組】模擬 T3：【佛山市選2013】海明距離

【佛山市選2013】海明距離 Description 對於二進位制串a，b，他們之間的海明距離是指兩個串異或之後串中1的個數。異或的規則為：

紀中暑假集訓 2020.08.08【NOIP提高組】模擬 T1：【NOIP2012模擬8.7】奶牛編號

【NOIP2012模擬8.7】奶牛編號 Description 作為一個神祕的電腦高手，Farmer John 用二進位制數字標識他的奶牛。