[HNOI2013]题解

最新推荐文章于 2021-12-14 16:31:07 发布
最新推荐文章于 2021-12-14 16:31:07 发布
阅读量189 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/zzy2005/p/10406638.html
版权

代码在最后

[HNOI2013]比赛

记忆化搜索

把每一位还需要多少分用\(27\)进制压进\(long\) \(long\),\(map\)记忆化一下即可

[HNOI2013]消毒

先考虑在二维平面

问题就是最小点覆盖

最小点覆盖 = 二分图最大匹配

对于每个点\((x,y)\),\(x\)连向\(y\)一条边,然后跑最大匹配

扩展到三维

好像不太好搞....

\(a*b*c<=5000\)

我们把\(a\)调换成\(min(a, b, c)\)

\(a\)最大为\(\sqrt[3]{5000}\)约\(17\)

对于每一层,要么和上面一起消,要么一次消掉这一层

枚举每层的状态

然后再跑最大匹配\(O(2^{17}n^3)\)

[HNOI2013]旅行

构造+单调队列

题目大意:给定\(1,-1\)组成的序列,分成\(m\)段,使得\(m\)段绝对值最大值最小

设:

后缀和为\(sum[i]\),后缀和为\(0\)的个数为\(cnt[i]\),序列和为\(S\)

然后分类讨论

  • \(S = 0\)

    \(1.\)若\(cnt[1] \ge m\),则\(ans = 0\).直接选\(0\)的位置即可

    维护一个单调队列

    \(2.\) 若\(cnt[1]<m\), 则\(ans = 1\)

    构造方法与 \(S \neq 0\) 一样

  • \(S \neq 0\)

    \(ans = \lceil\frac{|S|}{m}\rceil\)

    因为区间和为\(0\)的可以消掉,剩下的均分最小

    现在问题是如何求出字典序最小的方案

    假设上一个休息点已经确定为\(last\),当前决策到第\(i\)个休息点

    那么新的休息点(第i个休息点)$\(a\)需要满足:

    • \(n - a \ge m-i\)
    • \(\lceil \frac{|sum[a + 1]|}{m - i}\rceil \leq ans\)
    • \(|sum[last+1]-sum[a+1]| \leq ans\)

    好像不太好搞,考虑暴力

    我们可以对于每个每种\(sum\)开一个单调队列

    每次暴力从\([sum[last+1]-ans, sum[last+1]+ans]\) 取出合法的放进答案队列

    再维护答案队列的单调性,保证答案字典序最小

复杂度:\(O(m\lceil \frac{|S|}{m} \rceil) = O(|S|)\)

[HNOI2013]数列

\(20\%\):\(dp\)
\(f[i][j]\)前\(i\)位,已经分了\(j\)份
转移用前缀和优化一下
\(O(nk)\)

\(100\%\):

先写出式子:
设差分数组为:\(a_1, a_2, a_3, ..., a_{k-1}\)

\(\sum^{m}_{a_1 = 1}\sum^{m}_{a_2 = 1}\sum^{m}_{a_3 = 1}...\sum^{m}_{a_{k-1} = 1}(n-\sum_{i=1}^{k-1}a_i)\)
\(= n * m^{k-1} - \sum^{m}_{a_1 = 1}\sum^{m}_{a_2 = 1}\sum^{m}_{a_3 = 1}...\sum^{m}_{a_{k-1} = 1}\sum_{i=1}^{k-1}a_i\)
\(=n*m^{k-1}-\sum_{i=1}^{k-1}\sum_{a_i=1}^m*m^{k-2}\)
\(=n*m^{k-1}-(k-1)*m^{k-2}*\frac{(m+1)m}{2}\)

\(快速幂即可\)

  • 注意取模

[HNOI2013]游走

题面要求算边的期望

如果求出每条边期望经过次数,就可以求出答案

每条边经过次数,显然需要求出两端点期望经过次数

设点\(i\)期望次数为\(f[i]\)

\(deg[i]\)为\(i\)的入度

对于一个点\(i\)

存在边\(x-i\)

\(f[i] = \sum \frac{f[x]}{deg[x]}\)

\(f[1]\)要加\(1\),因为一开始在\(1\)

\(f[n]\)不要算,因为到了\(n\)就停止

这个东西列个方程,高斯消元求

然后算出每条边经过次数的期望
对于\(x-y\)
\(q[i] = f[x] / deg[x] + f[y] / deg[y]\)

显然经过次数多的边,赋值小

排序弄一下即可

[HNOI2013]切糕

最小割

题目其实就是求最小的代价使得每个纵轴被分成两部分

我们把每个点抽象成一条边，一个纵轴就是一条\(S−T\)的路径

但是题目要求\(|f(x,y)−f(x′,y′)|≤D\)
不能直接跑最小割

考虑如何限制

首先，\(|f(x,y)−f(x′,y′)|≤D\)是相互的
所以只要考虑 \(f(x,y)−f(x′,y′)≤D\)

那么对于\((x, y, z)\) 我们向它相邻列的第\(x-D\)层连一条\(inf\)边

贪心想一下,这样一定保证超过限制的两个点不会同时割掉

然后代码就很简单啦

Code

[HNOI2013]比赛

#include<bits/stdc++.h>

#define LL unsigned long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}

const int N = 15, Mod = 1e9 + 7;

int n, s[N], ans, a[N], b[N], cnt1, cnt2;

map<LL, LL> M;

bool cmp(int x, int y) {
    return x > y;
}

LL dfs(int x, int y) {
    if (a[x] + (n - y + 1) * 3 < s[x]) return 0;
    if (x == n) return 1;
    if (y > n) {
        for (int i = x + 1; i <= n; i++) b[i] = s[i] - a[i];
        sort(b + 1 + x, b + n + 1, cmp);
        LL S = n - x;
        for (int i = x + 1; i <= n; i++) S = S * 27 + b[i];
        if (M.find(S) != M.end()) return M[S];
        else return M[S] = dfs(x + 1, x + 2);
    }
    LL res = 0;

    if (a[x] + 3 <= s[x] && cnt1) {
        a[x] += 3;
        cnt1--;
        (res += dfs(x, y + 1)) %= Mod;
        a[x] -= 3;
        cnt1++;
    }
    if (a[x] < s[x] && a[y] < s[y] && cnt2) {
        a[x]++; a[y]++;
        cnt2--;
        (res += dfs(x, y + 1)) %= Mod;
        a[x]--; a[y]--;
        cnt2++;
    }
    if (a[y] + 3 <= s[y] && cnt1) {
        a[y] += 3;
        cnt1--;
        (res += dfs(x, y + 1)) %= Mod;
        a[y] -= 3;
        cnt1++;
    }
    return res;
}

int main() {
    read(n);
    int sum;
    for (int i = 1; i <= n; i++)
        read(s[i]), sum += s[i];
    sort(s+1, s+1+n, cmp);
    cnt1 = sum - n * (n - 1);
    cnt2 = (sum - cnt1 * 3) / 2;
    printf("%lld\n", dfs(1, 2));
    return 0;
}

[HNOI2013]消毒

#include<bits/stdc++.h>

#define LL long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}

const int N = 5010;

int a, b, c;

int q[3][N], ql, ans;

void init() {
    ql = 0;
    read(a), read(b), read(c);
    int mn = min(a, min(b, c));
    for (int i = 1; i <= a; i++)
        for (int j = 1; j <= b; j++)
            for (int k = 1; k <= c; k++) {
                int x; read(x);
                if (x == 1)
                    q[0][++ql] = i, q[1][ql] = j, q[2][ql] = k;
            }
    if (mn == b) {
        swap(a, b); swap(q[0], q[1]);
    }
    else if (mn == c) {
        swap(a, c); swap(q[0], q[2]);
    }
    return ;
}

bool flag[N], used[N];

int match[N];

struct node {
    int to, nxt;
}g[N];
int last[N], gl;

void add(int x, int y) {
    g[++gl] = (node) {y, last[x]};
    last[x] = gl;
}

bool dfs(int u) {
    for (int i = last[u]; i; i = g[i].nxt) {
        int v = g[i].to;
        if (used[v]) continue;
        used[v] = 1;
        if (!match[v] || dfs(match[v])) {
            match[v] = u;
            return 1;
        }
    }
    return 0;
}

void work(int S) {
    int res = 0;
    for (int i = 0; i < a; i++)
        if (S & (1 << i))
            flag[i + 1] = 1, res++;
        else flag[i + 1] = 0;
    memset(last, 0, sizeof(last)); gl = 0;
    memset(match, 0, sizeof(match));
    for (int i = 1; i <= ql; i++)
        if (!flag[q[0][i]])
            add(q[1][i], q[2][i]);
    for (int i = 1; i <= b; i++) {
        for (int j = 1; j <= c; j++) used[j] = 0;
        if (dfs(i)) res++;
    }
    ans = min(ans, res);
    return ;
}

int main() {
    int T;
    read(T);
    while (T--) {
        init();
        ans = 2147483647;
        for (int i = 0; i < (1 << a); i++)
            work(i);
        printf("%d\n", ans);
    }
    return 0;
}

[HNOI2013]旅行

#include<bits/stdc++.h>

#define LL long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}
const int N = 5e5 + 5; 
int n, m, a[N], sum[N], cnt[N];
struct Node { int l, r, v; } Line[N << 1]; int tot = 0; 
struct deque { 
    int head, tail, len;
    bool empty() { return !len; } 
    int newNode(int l, int r, int v) { Line[++tot] = (Node){ l, r, v }; return tot; }
    int front() { return Line[head].v; } 
    int back() { return Line[tail].v; } 
    void pop_back() { tail = Line[tail].l, len--; } 
    void pop_front() { head = Line[head].r, len--; } 
    void push_back(int v) { 
        if (!len)  head = tail = newNode(0, 0, v); 
        else Line[tail].r = newNode(tail, 0, v), tail = Line[tail].r; 
        len++; 
    } 
    void push(int v) { 
        while (len && a[back()] > a[v]) pop_back(); 
        push_back(v);
    } 
} Q[N << 1], Qu[N << 1], *q = Q + N, *qu = Qu + N;

#define min(x, y) ((a[x]) < (a[y]) ? (x) : (y))

int main() {
    read(n), read(m);
    for (int i = 1; i <= n; i++)
        read(a[i]), read(sum[i]), sum[i] = sum[i] ? 1 : -1;
    for (int i = n - 1; i >= 1; i--) sum[i] += sum[i + 1];
    for (int i = n; i >= 1; i--) cnt[i] = cnt[i + 1] + (!sum[i]);
    int S = sum[1], d = S ? ceil(1.0 * abs(S) / m) : cnt[1] < m;
    cnt[n + 1] = -1;
    if (!d) {
        for (int i = 1, j = 2; i < m; i++) {
            while (cnt[j + 1] >= m - i) {
                if (!sum[j + 1]) q[0].push(j);
                j++;
            }
            printf("%d ", a[q[0].front()]);
            q[0].pop_front();
        }
    }
    else {
        for (int i = 2; i <= n; i++) qu[sum[i]].push_back(i - 1);
        int last = 0;
        a[n + 1] = n + 1;
        for (int i = 1; i < m; i++) {
            int ans = n + 1;
            for (int j = sum[last + 1] - d; j <= sum[last + 1] + d; j++) {
                if (ceil(1.0 * abs(j) / (m - i)) > d) continue;
                while (!qu[j].empty() && n - qu[j].front() >= m - i) {
                    if (qu[j].front() > last) q[j].push(qu[j].front());
                    qu[j].pop_front();
                }
                while (!q[j].empty() && q[j].front() <= last)
                    q[j].pop_front();
                if (!q[j].empty()) ans = min(ans, q[j].front());
            }
            last = ans;
            printf("%d ", a[ans]);
        }
    }
    printf("%d\n", a[n]);
    return 0;
}

[HNOI2013]数列

#include<bits/stdc++.h>

#define LL long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}

LL n, k, m, p;

LL fastpow(LL a, LL b) {
    LL res = 1;
    for (; b; b >>= 1, a = a * a % p) if (b & 1) res = res * a % p; 
    return res;
}

int main() {
    //freopen(".in", "r", stdin);
    //freopen(".out", "w", stdout);
    read(n), read(k), read(m), read(p);
    LL ans = (n % p * fastpow(m, k - 1) % p - (k - 1) * fastpow(m, k - 2) % p * ((m + 1) * m / 2 % p) % p  + p) % p;
    write(ans);
    return 0;
}

[HNOI2013]游走

#include<bits/stdc++.h>

#define LL long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}

const int N = 510;

struct node {
    int to, nxt;
}g[N * 1000];
int last[N], gl, deg[N], n, m;
void add(int x, int y) {
    g[++gl] = (node) {y, last[x]};
    last[x] = gl;
    g[++gl] = (node) {x, last[y]};
    last[y] = gl;
    deg[y]++; deg[x]++;
}

double a[N][N];

void Gauss() {
    for (int i = 1, k; i < n; i++) {
        k = i;
        for (int j = i + 1; j < n; j++)
            if (fabs(a[k][i]) < fabs(a[j][i])) k = j;
        if (k != i) swap(a[k], a[i]);
        for (int j = i + 1; j < n; j++)
            for (int k = n; k >= i; k--)
                a[j][k] -= a[i][k] * a[j][i] / a[i][i];
    }
    for (int i = n - 1; i; i--) {
        for (int j = i + 1; j < n; j++)
            a[i][n] -= a[i][j] * a[j][n];
        a[i][n] /= a[i][i];
    }
    return ;
}

double q[N * N];

int X[N * N], Y[N * N];

int main() {
    read(n); read(m);
    for (int i = 1, x, y; i <= m; i++) {
        read(x), read(y);
        add(x, y);
        X[i] = x, Y[i] = y;
    }   
    for (int x = 1; x < n; x++) {
        a[x][x] = 1;
        for (int i = last[x]; i; i = g[i].nxt) {
            int v = g[i].to;
            if (v == n) continue;
            a[x][v] = -1.0 / deg[v];
        }
    }
    a[1][n] = 1;
    Gauss();
    for (int i = 1; i <= m; i++)
        q[i] = a[X[i]][n] / deg[X[i]] + a[Y[i]][n] / deg[Y[i]];
    sort(q + 1, q + 1 + m);
    double ans = 0;
    for (int i = 1; i <= m; i++)
        ans += q[i] * (m - i + 1);
    printf("%.3lf\n", ans);
    return 0;
}

[HNOI2013]切糕

#include<bits/stdc++.h>

#define LL long long
#define RG register

using namespace std;
template<class T> inline void read(T &x) {
    x = 0; RG char c = getchar(); bool f = 0;
    while (c != '-' && (c < '0' || c > '9')) c = getchar(); if (c == '-') c = getchar(), f = 1;
    while (c >= '0' && c <= '9') x = x*10+c-48, c = getchar();
    x = f ? -x : x;
    return ;
}
template<class T> inline void write(T x) {
    if (!x) {putchar(48);return ;}
    if (x < 0) x = -x, putchar('-');
    int len = -1, z[20]; while (x > 0) z[++len] = x%10, x /= 10;
    for (RG int i = len; i >= 0; i--) putchar(z[i]+48);return ;
}

const int N = 80000, inf = 2147483647;

struct node {
    int to, nxt, w;
}g[2000000];
int last[N], gl = 1;

void add(int x, int y, int z) {
    g[++gl] = (node) {y, last[x], z};
    last[x] = gl;
    g[++gl] = (node) {x, last[y], 0};
    last[y] = gl;
}

queue<int> q;
int dep[N], s, t, cur[N];

bool bfs() {
    memset(dep, 0, sizeof(dep));
    dep[s] = 1;
    q.push(s);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int i = last[u]; i; i = g[i].nxt) {
            int v = g[i].to;
            if (!dep[v] && g[i].w) {
                dep[v] = dep[u]+1;
                q.push(v);
            }
        }
    }
    return dep[t] == 0 ? 0 : 1;
}

int dfs(int u, int d) {
    if (u == t) return d;
    for (int &i = cur[u]; i; i = g[i].nxt) {
        int v = g[i].to;
        if (dep[v] == dep[u]+1 && g[i].w) {
            int di = dfs(v, min(d, g[i].w));
            if (di) {
                g[i].w -= di;
                g[i^1].w += di;
                return di;
            }
        }
    }
    return 0;
}

int Dinic() {
    int ans = 0;
    while (bfs()) {
        for (int i = 1; i <= t; i++) cur[i] = last[i];
        while (int d = dfs(s, inf)) ans += d;
    }
    return ans;
}

int a[50][50][50], id[50][50][50];

int fx[] = {0, 1, -1, 0};
int fy[] = {1, 0, 0, -1};

int main() {
    int p, q, r, d, tot = 0;
    read(p), read(q), read(r), read(d);
    for (int i = 1; i <= r; i++)
        for (int j = 1; j <= p; j++)
            for (int k = 1; k <= q; k++)
                read(a[i][j][k]), id[i][j][k] = ++tot;
    for (int j = 1; j <= p; j++)
        for (int k = 1; k <= q; k++)
            id[r+1][j][k] = ++tot;          
    s = tot+1, t = s+1;
    for (int i = 1; i <= p; i++)
        for (int j = 1; j <= q; j++)
            add(s, id[1][i][j], inf), add(id[r+1][i][j], t, inf);
    
    for (int k = 1; k <= r; k++)
        for (int i = 1; i <= p; i++)
            for (int j = 1; j <= q; j++)
                add(id[k][i][j], id[k+1][i][j], a[k][i][j]);
    
    for (int k = d+1; k <= r+1; k++)
        for (int i = 1; i <= p; i++)
            for (int j = 1; j <= q; j++) {
                for (int z = 0; z < 4; z++) {
                    int x = i + fx[z], y = j + fy[z];
                    if (x < 1 || y < 1 || x > p || y > q) continue;
                    add(id[k][i][j], id[k-d][x][y], inf);
                }
            }
    
    printf("%d\n", Dinic());
    return 0;
}

转载于:https://www.cnblogs.com/zzy2005/p/10406638.html

weixin_30783913
关注
[CQOI2009]循环赛&&[HNOI2013]比赛
qq_42645435的博客
02-08 704
[CQOI2009]循环赛&amp;amp;&amp;amp;[HNOI2013]比赛——真是好题（差点没把我脑子烧坏…sd的无奈） 提前声明：感谢大佬看了他的题解后，我才恍然大悟 …好，先上题目 [CQOI2009]循环赛题目描述 原题传送门. n队伍比赛，每两支队伍比赛一次，平1胜3负0.给出队伍的最终得分，求多少种可能的分数表。 输入输出格式 输入格式：第一行包含一个正整数n，队伍的个数。第二行包含n个非...
BZOJ3141: [Hnoi2013]旅行（单调队列）
DZYO的博客
04-04 544
传送门 题解： 相当于给一个ai={1,−1}ai={1,−1}a_i= \{1,-1\}的序列，划分为mmm段使得每段绝对值最小。 记sumsumsum 为序列之和。 容易发现答案为|sum|m|sum|m\frac{|sum|}{m}。 注意当|sum|=0|sum|=0|sum|=0时有特殊情况。 我们记si=∑ni=iaisi=∑i=inais_{i}=\sum_{i=i}^n ...
[luogu3231 HNOI2013] 消毒 (二分图最小点覆盖)
Tricksterism
08-20 243
传送门 Description 最近在生物实验室工作的小T遇到了大麻烦。 由于实验室最近升级的缘故，他的分格实验皿是一个长方体,其尺寸为a*b*c，a、b、c 均为正整数。为了实验的方便，它被划分为a*b*c个单位立方体区域，每个单位立方体尺寸为1*1*1。用(i,j,k)标识一个单位立方体，1 &amp;lt;=i&amp;lt;=a，1&amp;lt;=j&amp;lt;=b，1&amp;lt;=k&amp;lt;=c。这个实验皿已经很...
【HNOI2013】比赛
Andy&Calrn的博客
12-25 586
题目 沫沫非常喜欢看足球赛，但因为沉迷于射箭游戏，错过了最近的一次足球联赛。此次联赛共N 支球队参加，比赛规则如下： (1) 每两支球队之间踢一场比赛。 (2) 若平局，两支球队各得1 分。 (3) 否则胜利的球队得3 分，败者不得分。 尽管非常遗憾没有观赏到精彩的比赛，但沫沫通过新闻知道了每只球队的最后总得分，然后聪明的她想计算出有多少种可能的比赛过程。 譬如有3 支球队，每支球队最
bzoj3144: [Hnoi2013]切糕
weixin_30339457的博客
12-29 147
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3144 第一道想出来的hnoi题，还难得地一遍A... 思路：老方法，先只考虑一个限制条件，即每个竖轴选一个点，求最小和； 最小，就考虑最小割。 这个还是比较好想的，每根竖轴按从上到下的顺序，连出从S->T一条路径，把点权附到边上 最小割就相当于每条链选...
【HNOI2013】数列
Andy&Calrn的博客
12-13 952
题目小T最近在学着买股票，他得到内部消息：F公司的股票将会疯涨。股票每天的价格已知是正整数，并且由于客观上的原因，最多只能为N。在疯涨的K天中小T观察到：除第一天外每天的股价都比前一天高，且高出的价格（即当天的股价与前一天的股价之差）不会超过M，M为正整数。并且这些参数满足M(K-1)分析我们发现若是从他们的各自股价开始入手，问题会变得很困难， 于是我们可以从有限定的m入手，即每两天之间股价的差：
【题解】[HNOI2013] 切糕
cqbzlydd的博客
12-14 551
sol： 比较难的网络流题目。 我们考虑，对于一个 (i,j) 的块拆分成 r 个串联，每个点向前一个连边，容量为 a[r][i][j] 。 那么选择一个点相当于割掉它面前的那条边。 以 v2 为例。假设选了 v2 点，那么 {p1,p2,p3} 是合法的。 为了保证割边在 {p1,p2,p3} 面前的边中，我们添加一条边： 当然 p2 同理也这样添。 最后网络流跑最小割即可。 #include<bits/stdc++.h> #define INF 0x3f3f3f3f using na.
HNOI2014题解及数据
05-14
【HNOI2014题解及数据】是一份针对中国高中生信息学奥林匹克竞赛（HNOI）2014年的参赛者准备的重要资源。这份资料包包含了当年比赛的题目解析、样例代码和相关的数据集，对于参赛者或者对信息学竞赛有兴趣的学习者来...
[HNOI2011]数学作业 题解
莫莫 dicol 的博客
09-25 261
[HNOI2011]数学作业 [HNOI2011]数学作业。 直接考虑 Dp\tt DpDp 显然 fi=fi−1×10x+if_i = f_{i - 1} \times 10^{x} + ifi​=fi−1​×10x+i。那么我们直接将其分段进行计算即可。 具体的矩阵： [1ifi] \left[ \begin{matrix} 1 & i & f_i \end{matrix} \right] [1​i​fi​​] [1100110010x] \left[ \begin{matrix}
[HNOI2002]公交车路线 题解
莫莫 dicol 的博客
09-25 232
[HNOI2002]公交车路线 [HNOI2002]公交车路线 这题和没有一样。 直接按照题意建立转移矩阵即可。 笔者的答案矩阵是： [fAfBfC…fH] \left[ \begin{matrix} f_{A} & f_B & f_C & \dots & f_H \end{matrix} \right] [fA​​fB​​fC​​…​fH​​] 其中 fif_ifi​ 表示经过了 nnn 次操作从 AAA 走到 iii 的方案数。 不妨设转移矩阵为 GGG。那么对于
[HNOI2013]消毒
Brute♂force
10-12 333
题目 https://www.luogu.org/problemnew/show/P3231 思路 首先考虑二维 显然，这么染是最佳的 所以我们建立二分图，对于每个黑色块 (x,y)(x,y)，我们将其处于第一部的 xx 与处于第二部的 yy 连接，求一个最小点覆盖。二分图中最小点覆盖=最大匹配，就得到了答案。 而现在是三维 看到题目中有abc&lt;=5000a∗b∗c&lt;=5000，也...
[Hnoi2013]消毒
u012647218的专栏
02-05 751
[Hnoi2013]消毒 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 376  Solved: 158 [Submit][Status] Description 最近在生物实验室工作的小T遇到了大麻烦。 由于实验室最近升级的缘故，他的分格实验皿是一个长方体,其尺寸为a*b*c，a、b、c 均为正整数。为了实验的方便，它被划分为
【HNOI2013】游走
时光真疯狂, 我一路执迷于匆忙.
03-21 1219
Description给出一张n个点，m条边的无向连通图。有一个人从点1开始随机游走，到点n结束。他每走过一条边就会得到其编号的分数。（可以重复走而重复得分）。现在让你安排每条边的编号，让他的得分期望值最小。求这个最小值。 n<=500Solution我们发现只要求出每条边的期望经过次数，然后从大到小排序，依次编号，就一定是最小值了。（即期望大的编号要小） 但是，每条边的期望经过次数要怎么求呢？
3142: [Hnoi2013]数列
limboman的博客
12-08 365
设差分数组a 有:ans=Σa(n−ΣK−1i=1a[i])ans=\Sigma_a(n-\Sigma_{i=1}^{K-1}a[i]) 可拆分a[i]的贡献解决问题 教训： 一开始的思路就是尝试移动开头，但没有想到差分求和，而是怎样求以数x结尾的方案数 然后果断转化模型，通过差分容斥搞到了一个O（K）的麻烦组合式 再尝试生成函数，但回推的时候有一个卷积消不掉（能力有限……），强
[HNOI2013]游走
BeNoble_的博客
03-30 861
题意 从111开始每次等概率随机选择一条边走下去,直到走到nnn为止 定义一条边的期望是走到他的期望次数××\times他的编号 让你给这些边编号,使得期望最小 题解 可以贪心地考虑期望大的边编号要小,期望小的编号要大 定义pipip_i表示走到点iii的期望走过的次数,didid_i表示iii的点度 考虑走过一条边(u,v)(u,v)(u,v)的期望次数Ei=pudu+pv...
【HNOI2013】切糕
OI技术宅
02-22 1254
【HNOI2013】切糕 【题目描述】 经过千辛万苦小 A 得到了一块切糕，切糕的形状是长方体，小 A 打算拦腰将切糕切成两半分给小 B。出于美观考虑，小 A 希望切面能尽量光滑且和谐。于是她找到你，希望你能帮她找出最好的切割方案。  出于简便考虑，我们将切糕视作一个长 P、宽 Q、高 R 的长方体点阵。我们将位于第 z层中第 x 行、第 y 列上(1≤x≤P, 1≤y≤Q, 1≤z≤R
[HNOI 2013]数列
weixin_30955617的博客
03-10 80
Description 题库链接 给你四个数 \(N,K,M,P\) ，让你生成一段长度为 \(K\) 严格单调递增序列，并且满足： 第一位可以为任意元素； 相邻两位的差值不超过 \(M\) ； 序列中元素大小不超过 \(N\) 。 求满足上述要求不同的生成序列有多少个，对 \(P\) 取模。 \(1\leq N\leq 10^{18},1\leq K,M,P\leq 10^9\) Solut...
bzoj3142: [Hnoi2013]数列
weixin_30576827的博客
12-28 117
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3142 思路：首先我们假设初值固定，无视上限，那么我们就可以看成是走K-1步，每步有M种走法 那方案数就是M^(k-1) 但是初值不固定，枚举是不现实的，因为如果起点较为靠后，我们就不能无视上限，方案是无法统计的 但这给我们一个启示，走的每步不就是差分数组吗 于是我们可以考虑...
【bzoj3139】[Hnoi2013]比赛
Circus
04-05 683
特技暴搜，记忆化搜索
网络流进阶：Model VII移民站选址与HNOI2013切糕问题
以HNOI2013的BZOJ3144——切糕1为例，题目设定在一个p×q的网格上，每个位置有r个可选值，并且每个选择都有成本。关键挑战是确保相邻四连通区域内的值差不超过d，目标是找到最小的总成本。在这个问题中，作者通过将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值