湖师大集训记录

最新推荐文章于 2024-07-07 09:49:57 发布
最新推荐文章于 2024-07-07 09:49:57 发布
阅读量776 收藏
点赞数
分类专栏： OI ---其他---
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OIljt12138/article/details/73731521
版权

湖师大集训记录

lyoi303:「2017 山东一轮集训 Day1」Sum

吕老板讲的方法只有50….

TLE

#include <bits/stdc++.h>
using namespace std;

int p, n, m;
const int mod = 998244353, g = 3;

int power(int a, int n)
{
    int ans = 1, b = a;
    for (register int i = 0; i <= 30; i++) {
        if ((n>>i)&1) ans = (long long)ans*b%mod;
        b = (long long)b*b%mod;
    }
    return ans;
}

inline int inv(int a)
{ return power(a, mod-2); }

const int MAXN = 2049;
int rev[MAXN];
void NTT(int a[], int n, int flag)
{
    int m = 1, lgn = 0;
    while (m < n) lgn++, m <<= 1;
    rev[0] = 0;
    for (register int i = 1; i < n; i++) rev[i] = (rev[i>>1]>>1)|((i&1)<<(lgn-1));
    for (register int i = 0; i < n; i++)
        if (rev[i] < i) swap(a[i], a[rev[i]]);
    for (register int k = 1; k <= n; k <<= 1) {
        int dw = power(g, (mod-1)/k);
        if (flag == -1) dw = inv(dw);
        for (register int i = 0; i < n; i += k) {
            int w = 1;
            for (register int j = 0; j < k>>1; j++) {
                int u = a[i+j], t = (long long)w*a[i+j+(k>>1)]%mod;
                a[i+j] = (u+t)%mod, a[i+j+(k>>1)] = ((u-t)%mod+mod)%mod;
                w = (long long)w*dw%mod;
            }
            }
        }
    if (flag == -1) {
        int Inv = inv(n);
        for (register int i = 0; i < n; i++)
            a[i] = (long long)Inv*a[i]%mod;
    }
}

int B[2049], C[2049];
void mul(int a[2049], int M, int b[2049], int c[2049]) // $a = b\oplus c$
{
    memcpy(B, b, sizeof B), memcpy(C, c, sizeof C);
    memset(a, 0, sizeof B);
    int n = 1;
    while (n < M) n <<= 1;
    n <<= 1; // todo here
    NTT(B, n, 1), NTT(C, n, 1);
    for (register int i = 0; i < n; i++)
        a[i] = (long long)B[i]*C[i]%mod;
    NTT(a, n, -1);
    for (register int i = M; i < 2048; i++)
        a[i] = 0;
}

struct node {
    int N, Pow;  // 10^N = Pow;
    int A[55][2049];
    void print()
    {
        puts("Matrix : ");
        for (int i = 0; i < p; i++) {
            for (int j = 0; j <= m; j++)
                cerr << A[i][j] << " ";
            cerr << endl;
        }
        puts("End Matrix.");
    }
    node() {
        memset(A, 0, sizeof A);
    }
    friend node operator * (node &a, node &b)
    {
        node ret;
        static int A[MAXN];
        memset(A, 0, sizeof A);
        ret.N = a.N+b.N, ret.Pow = (long long)a.Pow*b.Pow%p;
        for (register int i = 0; i < p; i++) {
            for (register int j = 0; j < p; j++) {
                int M = ((long long)i*b.Pow%p+j)%p;
                mul(A, m+1, a.A[i], b.A[j]);
                for (register int k = 0; k <= m; k++) (ret.A[M][k] += A[k]) %= mod;
            }
        }
        return ret;
    }
};

node power(node a, int n)
{
    node ans;
    int flag = -1;
    for (int i = 0; i <= 30; i++) {
        if ((n>>i) == 0) break;
        if ((n>>i)&1) {
            if (flag == -1) ans = a, flag = 1;
            else ans = ans*a;
        }
        a = a*a;
    }
    return ans;
}

node A;

int a[MAXN], b[MAXN], c[MAXN];
int main()
{
    scanf("%d%d%d", &n, &p, &m);
    A.N = 1, A.Pow = 10;
    for (int j = 0; j <= min(m, 9); j++)
    A.A[j%p][j]++;
    A = power(A, n);
    int ans = 0;
    for (int i = 0; i <= m; i++) {
        ans = (ans+A.A[0][i])%mod;
        printf("%d ", ans);
    }
    puts("");
    return 0;
}

upd: 原来是我走神了QwQ。
做循环卷积的时候要先全部DFT，卷完了全部IDFT，复杂度少一个 log …
AC…

#include <bits/stdc++.h>
using namespace std;

int p, n, m;
const int mod = 998244353, g = 3;

int power(int a, int n)
{
    int ans = 1, b = a;
    for (register int i = 0; i <= 30; i++) {
        if ((n>>i)&1) ans = (long long)ans*b%mod;
        b = (long long)b*b%mod;
    }
    return ans;
}

inline int inv(int a)
{ return power(a, mod-2); }

const int MAXN = 2049;
int rev[MAXN];
void NTT(int a[], int n, int flag)
{
    int m = 1, lgn = 0;
    while (m < n) lgn++, m <<= 1;
    rev[0] = 0;
    for (register int i = 1; i < n; i++) rev[i] = (rev[i>>1]>>1)|((i&1)<<(lgn-1));
    for (register int i = 0; i < n; i++)
        if (rev[i] < i) swap(a[i], a[rev[i]]);
    for (register int k = 1; k <= n; k <<= 1) {
        int dw = power(g, (mod-1)/k);
        if (flag == -1) dw = inv(dw);
        for (register int i = 0; i < n; i += k) {
            int w = 1;
            for (register int j = 0; j < k>>1; j++) {
                int u = a[i+j], t = (long long)w*a[i+j+(k>>1)]%mod;
                a[i+j] = (u+t)%mod, a[i+j+(k>>1)] = ((u-t)%mod+mod)%mod;
                w = (long long)w*dw%mod;
            }
            }
        }
    if (flag == -1) {
        int Inv = inv(n);
        for (register int i = 0; i < n; i++)
            a[i] = (long long)Inv*a[i]%mod;
    }
}

int B[2049], C[2049];
void mul(int a[2049], int M, int b[2049], int c[2049]) // $a = b\oplus c$
{
    memcpy(B, b, sizeof B), memcpy(C, c, sizeof C);
    memset(a, 0, sizeof B);
    int n = 1;
    while (n < M) n <<= 1;
    n <<= 1; // todo here
    cerr << n << endl;
    NTT(B, n, 1), NTT(C, n, 1);
    for (register int i = 0; i < n; i++)
        a[i] = (long long)B[i]*C[i]%mod;
    NTT(a, n, -1);
    for (register int i = M; i < 2048; i++)
        a[i] = 0;
}

struct node {
    int N, Pow;  // 10^N = Pow;
    int A[55][2049];
    void display()
    {
        puts("Matrix : ");
        for (int i = 0; i < p; i++) {
            for (int j = 0; j <= m; j++)
                cerr << A[i][j] << " ";
            cerr << endl;
        }
        puts("End Matrix.");
    }
    node() {
        memset(A, 0, sizeof A);
    }
    friend node operator * (node a, node b)
    {
        node ret;
        static int C[55][MAXN], d[MAXN];
        memset(C, 0, sizeof C);
        ret.N = a.N+b.N, ret.Pow = (long long)a.Pow*b.Pow%p;
        int np = 1;
        while (np < m+1) np <<= 1;
        np <<= 1; // todo here
            for (int i = 0; i < p; i++) NTT(a.A[i], np, 1), NTT(b.A[i], np, 1);
        for (int i = 0; i < p; i++) {
            for (int j = 0; j < p; j++) {
                int M = ((long long)i*b.Pow%p+j)%p;
                for (int k = 0; k < np; k++)
                        C[M][k] = (C[M][k]+(long long)a.A[i][k]*b.A[j][k]%mod)%mod;
            }
        }
        for (int i = 0; i < p; i++) {
            NTT(a.A[i], np, -1), NTT(b.A[i], np, -1),
            NTT(C[i], np, -1);
            for (int k = 0; k <= m; k++) ret.A[i][k] = (ret.A[i][k]+C[i][k])%mod;
        }
        return ret;
    }
};

node power(node a, int n)
{
    node ans;
    int flag = -1;
    for (int i = 0; i <= 30; i++) {
        if ((n>>i) == 0) break;
        if ((n>>i)&1) {
            if (flag == -1) ans = a, flag = 1;
            else ans = ans*a;
        }
        a = a*a;
    }
    return ans;
}

node A;

int a[MAXN], b[MAXN], c[MAXN];
int main()
{
        scanf("%d%d%d", &n, &p, &m);
    A.N = 1, A.Pow = 10;
        for (int j = 0; j <= min(m, 9); j++)
        A.A[j%p][j]++;
    A = power(A, n);
    int ans = 0;
    for (int i = 0; i <= m; i++) {
        ans = (ans+A.A[0][i])%mod;
        printf("%d ", ans);
    }
    puts("");
    return 0;
}

lyoi306「2017 山东一轮集训 Day2」Pair

考虑匹配条件 ai+bj≥h ，令 Bj=h−bj 也就是 ai≥Bj 。显然，一个序列匹配当且仅当排序后匹配。考虑排序后 n 个ak和 n 个Bk的情况，容易发现，匹配当且仅当(排序后)对于任何一个前缀， a 的数量不少于B。如果把 a 看成左括号，B看成右括号，就是经典的括号序列匹配问题了。 a=−1,B=1 用线段树维护前缀和的区间最小值即可。

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 150005;
int gt[MAXN];
int n, m, h;

struct p {
    int dt, pos;
    friend bool operator < (const p &a, const p &b)
    {
        if (a.dt == b.dt) return a.pos < b.pos;
        return a.dt < b.dt;
    }
}a[MAXN], b[MAXN], dx[MAXN+MAXN];

int A[MAXN], B[MAXN], dx_top = 0;

void dx_init()
{
    for (int i = 1; i <= m; i++) dx[++dx_top] = b[i];
    for (int i = 1; i <= n; i++) dx[++dx_top] = a[i];
    sort(dx+1, dx+dx_top+1);
}

inline int dx_num(const p &a)
{ return lower_bound(dx+1, dx+dx_top+1, a)-dx; }

struct tree {
    int dat[MAXN*4], l[MAXN*4], r[MAXN*4], lc[MAXN*4], rc[MAXN*4], tag[MAXN*4], top, root;
    inline void clear()
    { top = root = 0; }
    tree()
    { clear(); }
    void build(int &nd, int opl, int opr)
    {
        nd = ++top, dat[nd] = tag[nd] = 0, l[nd] = opl, r[nd] = opr;
        if (opl < opr)
            build(lc[nd], opl, (opl+opr)/2), build(rc[nd], (opl+opr)/2+1, opr);
    }
    void pdw(int nd)
    {
        if (!nd) return;
        if (lc[nd]) tag[lc[nd]] += tag[nd], tag[rc[nd]] += tag[nd];
        dat[nd] += tag[nd], tag[nd] = 0;
    }
    inline void update(int nd)
    { if (lc[nd]) dat[nd] = min(dat[lc[nd]], dat[rc[nd]]); }
    void modify(int nd, int opl, int opr, int dt)
    {
        pdw(nd);
        if (l[nd] == opl && r[nd] == opr) tag[nd] += dt;
        else {
            int mid = (l[nd]+r[nd])/2;
            if (opr <= mid) modify(lc[nd], opl, opr, dt);
            else if (opl > mid) modify(rc[nd], opl, opr, dt);
            else modify(lc[nd], opl, mid, dt), modify(rc[nd], mid+1, opr, dt);
            pdw(lc[nd]), pdw(rc[nd]), update(nd);
        }
    }
    int query(int nd, int opl, int opr)
    {
        pdw(nd);
        if (l[nd] == opl && r[nd] == opr) return dat[nd];
        int mid = (l[nd]+r[nd])/2;
        if (opr <= mid) return query(lc[nd], opl, opr);
        else if (opl > mid) return query(rc[nd], opl, opr);
        else return min(query(lc[nd], opl, mid), query(rc[nd], mid+1, opr));
    }
    void display()
    {
        for (int i = 1; i <= dx_top; i++) printf("%d ", query(root, i, i));
        puts("");
    }
} seg;

int main()
{
    scanf("%d%d%d", &n, &m, &h);
        for (int i = 1; i <= m; i++)
        scanf("%d", &b[i].dt), b[i].dt = h-b[i].dt, b[i].pos = -i;
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i].dt), a[i].pos = i;
    dx_init();
    for (int i = 1; i <= m; i++) B[i] = dx_num(b[i]);//, printf("%d ", B[i]);
    for (int i = 1; i <= n; i++) A[i] = dx_num(a[i]);//, printf("%d ", A[i]);
    seg.build(seg.root, 1, dx_top);
    for (int i = 1; i <= m; i++) seg.modify(seg.root, B[i], dx_top, 1);
    int cnt = 0;
    for (int i = 1; i <= m; i++) seg.modify(seg.root, A[i], dx_top, -1);
    for (int i = 1; i <= n; i++) {
        if (seg.query(seg.root, 1, dx_top) >= 0) cnt++;
        seg.modify(seg.root, A[i], dx_top, 1);
        if (i+m > n) break;
        seg.modify(seg.root, A[i+m], dx_top, -1);
    }
    printf("%d\n", cnt);
    return 0;
}

lyoi323. 「2017 山东一轮集训 Day7」养猫

神奇的费用流…最大流限制/费用计算的好模型。

from visit_world
把 1 到 n 串成一条链
考虑上限：
想象你带了 mx 个小弟在链上走，到一个位置 p，你可以派出一个小弟去获得对应收益，但是他在 p + k 的时候才能归队
考虑下限：
在 p 这里派出一个小弟，会使得 [p, p+k) 上走“主干道”的小弟减少一名。
因此，我们限制“主干道”的流量为 mx - mi 即可满足下限

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1005;
int n, k, ms, me;
int mx, mn;

int s[MAXN], e[MAXN];

struct node {
    int to, next, flow;
    long long cost;
    int neg;
} edge[MAXN*200];
int head[MAXN], top = 0;
inline int push(int i, int j, int f, long long c)
{
    ++top, edge[top] = (node) {j, head[i], f, c, top+1}, head[i] = top;
    ++top, edge[top] = (node) {i, head[j], 0, -c, top-1}, head[j] = top;
    return top-1;
}

long long dis[MAXN];
int vis[MAXN];
queue<int> que;
int pre[MAXN], pre_edge[MAXN];
int S = MAXN-1, T = MAXN-2;
const long long inf = 1e14;
bool spfa(int &flow, long long &cost)
{
    memset(vis, 0, sizeof vis), memset(dis, 127/3, sizeof dis);
    vis[S] = 1, dis[S] = 0, que.push(S);
    while (!que.empty()) {
        int nd = que.front(); que.pop(), vis[nd] = 0;
        for (int i = head[nd]; i; i = edge[i].next) {
            int to = edge[i].to;
            if (!edge[i].flow || dis[to] <= dis[nd]+edge[i].cost) continue;
            dis[to] = dis[nd]+edge[i].cost, pre[to] = nd, pre_edge[to] = i;
            if (!vis[to])
                vis[to] = 1, que.push(to);
        }
    }
    if (dis[T] > inf) return 0;;
    int mf = INT_MAX;
    for (int i = T; i != S; i = pre[i]) mf = min(mf, edge[pre_edge[i]].flow);
    for (int i = T; i != S; i = pre[i]) 
        edge[pre_edge[i]].flow -= mf, edge[edge[pre_edge[i]].neg].flow += mf;
    cost += dis[T]*mf;
    flow += mf;
    return 1;
}

void mcf(int &flow, long long &cost)
{
    cost = flow = 0;
    while (spfa(flow, cost));
}

int eg[MAXN];

int main()
{
    scanf("%d%d%d%d", &n, &k, &ms, &me); // change t, t \le me, k-t \le ms \rightarrow t \ge k-ms
    mx = k-ms, mn = me; // [mn, mx]
    long long cnt = 0;
    for (int i = 1; i <= n; i++) scanf("%d", &s[i]), cnt += s[i]; // sleep
    for (int i = 1; i <= n; i++) scanf("%d", &e[i]);
    push(S, 1, mx, 0), push(n, T, mx, 0);
    for (int i = 1; i < n; i++) {
        if (i >= k) push(i, i+1, mx-mn, 0);
        else push(i, i+1, mx, 0);
    }
    for (int i = 1; i <= n; i++) {
        int t = i+k <= n?i+k:T;
        eg[i] = push(i, t, 1, -e[i]+s[i]);
    }
    int flow;
    long long cost;
    mcf(flow, cost);
    printf("%lld\n", cnt-cost);
    for (int i = 1; i <= n; i++) {
        if (edge[eg[i]].flow)
            putchar('S');
        else putchar('E');
    }
    puts("");
    return 0;
}

loj#6060. 「2017 山东一轮集训 Day1」Set

首先有 x1⊕x2 为定值，设为 x 。考虑x的每一位，如果为1，由于必然一边为1一边为0，对和的贡献不变；如果为0，则应该尽可能让更高位两边全为1。

做法1：首先取出 x 为0的位做一遍最大异或找到x2中必须为1的位置，然后作出线性基。贪心的从高到低放置每一位，用异或方程组判断下面是否有解「太麻烦了根本写不出来…」
// 但这个思路扩展性更好，可以出道题233

做法2：考虑统一处理，在贪心求最大异或的时候改变贪心顺序，首先是 x 为0的位，然后是为1的。直接做就好了。

#include <bits/stdc++.h>
using namespace std;

struct linear_base {
    long long A[70];
    void push(long long x, long long lim)
    {
        for (int i = 60; i >= 0; i--) {
            if (lim&(1ll<<i)) continue;
            if (!(x&(1ll<<i))) continue;
            if (!A[i]) { A[i] = x; return;}
            else x ^= A[i];
        }
            for (int i = 60; i >= 0; i--) {
            if (!(lim&(1ll<<i))) continue;
            if (!(x&(1ll<<i))) continue;
            if (!A[i]) { A[i] = x; return; }
            else x ^= A[i];
        }
    }
    long long max_xor(long long lim)
    {
        long long val = 0;
        for (int i = 60; i >= 0; i--)
            if (!(lim&(1ll<<i)) && !(val&(1ll<<i)))
                val ^= A[i];
        for (int i = 60; i >= 0; i--)
            if ((lim&(1ll<<i)) && !(val&(1ll<<i)))
                val ^= A[i];
            return val;
    }
} lb;
int n;
long long val[100005], xr = 0;

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%lld", &val[i]),  xr ^= val[i];
    for (int i = 1; i <= n; i++)
        lb.push(val[i], xr);
    printf("%lld\n", xr^lb.max_xor(xr));
    return 0;
}

loj #6068. 「2017 山东一轮集训 Day4」棋盘

套路题。首先行列划分，中间连线表示格子，考虑计算代价。不妨在S→Row的地方计算一行的代价， Column→T 的地方计算一列的代价。一行/列中有 n 个棋子，产生的代价为n(n−1)2，这是一个下凸函数，直接差分建边就好了。

可以动态加边，但不加也过了。

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 3005;
struct node {
    int to, next, flow, cost, neg;
} edge[MAXN*3005];
int head[MAXN], top = 0;
inline void push(int i, int j, int f, int c)
{
    ++top, edge[top] = (node){j, head[i], f, c, top+1}, head[i] = top;
    ++top, edge[top] = (node){i, head[j], 0, -c, top-1}, head[j] = top;
}

int dis[MAXN], vis[MAXN];
queue<int> que;
int pre[MAXN], pre_edge[MAXN];
const int S = MAXN-1, T = MAXN-2, inf = 233333333;

bool spfa(int &flow, int &cost)
{
    memset(dis, 127/3, sizeof dis), memset(vis, 0, sizeof vis);
    vis[S] = 1, dis[S] = 0, que.push(S);
    while (!que.empty()) {
        int nd = que.front(); que.pop(); vis[nd] = 0;
        for (int i = head[nd]; i; i = edge[i].next) {
            int to = edge[i].to;
                if (edge[i].flow == 0 || dis[to] <= dis[nd]+edge[i].cost) continue;
            dis[to] = dis[nd]+edge[i].cost, pre[to] = nd, pre_edge[to] = i;
            if (!vis[to])
                vis[to] = 1, que.push(to);
        }
    }
    if (dis[T] > inf) return 0;
    int maxf = inf;
    for (int i = T; i != S; i = pre[i]) maxf = min(maxf, edge[pre_edge[i]].flow);
    for (int i = T; i != S; i = pre[i]) {
        edge[pre_edge[i]].flow -= maxf;
        edge[edge[pre_edge[i]].neg].flow += maxf;
    }
    flow += maxf, cost += maxf*dis[T];
    return 1;
}

void mcf(int &flow, int &cost)
{ while (spfa(flow, cost)); }

int top_pt = 0;

int n;
char str[55][55];
int ptlr[55][55], ptud[55][55];
int cnt = 0, g[MAXN], s = T-1;

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%s", str[i]+1);
        for (int j = 1; j <= n; j++)
            if (str[i][j] == '.')
                cnt++;
    }
    for (int i = 1; i <= n; i++) {
        int pt = 1;
        while (pt <= n) {
            while (pt <= n && str[i][pt] == '#') pt++;
            if (pt > n) continue;
            ++top_pt;
            for (int j = 0; j <= n; j++)
                push(s, top_pt, 1, j);
            while (pt <= n && str[i][pt] == '.') ptlr[i][pt++] = top_pt;
        }
    }
    for (int i = 1; i <= n; i++) {
        int pt = 1;
        while (pt <= n) {
            while (pt <= n && str[pt][i] == '#') pt++;
            if (pt > n) continue;
            ++top_pt;
            for (int j = 0; j <= n; j++)
                push(top_pt, T, 1, j);
            while (pt <= n && str[pt][i] == '.') ptud[pt++][i] = top_pt;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (str[i][j] == '.')
                push(ptlr[i][j], ptud[i][j], 1, 0);
        }
    }
    g[0] = 0;
    int flow = 0, cost = 0;
    for (int i = 1; i <= cnt; i++) {
        push(S, s, 1, 0);
        mcf(flow, cost);
        //cerr << flow << endl;
        g[i] = cost;
    }
    int k; scanf("%d", &k);
    while (k--) {
        int t; scanf("%d", &t);
        printf("%d\n", g[t]);
    }
    return 0;
}

loj#2254. 「SNOI2017」一个简单的询问

考虑莫队。想到 get(l,r,x)=get(1,r,x)−get(1,l−1,x) 就很简单了。



#include <bits/stdc++.h>
using namespace std;

const int MAXN = 50005;

struct query {
    int l1, r1, l2, r2;
} qy[MAXN];

int sqrtN;
int n, q;

struct qs {
    int r1, r2;
    int id, num; // num = 0,1,2,3
    friend bool operator < (const qs &a, const qs &b)
    {
        if (a.r1/sqrtN == b.r1/sqrtN) return a.r2 < b.r2;
        return a.r1 < b.r1;
    }
} qys[MAXN*4];
int qtop = 0;

long long ans[MAXN][4];
int a[MAXN];
int A[MAXN], B[MAXN]; // 出现次数

void solve_q()
{
    sort(qys+1, qys+qtop+1);
    int L = qys[1].r1, R = qys[1].r2;
        for (int i = 1; i <= L; i++) A[a[i]]++;
    for (int j = 1; j <= R; j++) B[a[j]]++;
    long long Ans = 0;
    for (int i = 1; i <= n; i++) Ans += (long long)A[i]*B[i];
    for (int i = 1; i <= qtop; i++) {
        // cerr << qys[i].r1 << " -- " << qys[i].r2 << " " << A[1] << " " << B[1] << endl; 
        while (L < qys[i].r1) L++, A[a[L]]++, Ans += B[a[L]];
        while (L > qys[i].r1) A[a[L]]--, Ans -= B[a[L]], L--;
        while (R < qys[i].r2) R++, B[a[R]]++, Ans += A[a[R]];
        while (R > qys[i].r2) B[a[R]]--, Ans -= A[a[R]], R--;
        // cerr << Ans << endl;
        ans[qys[i].id][qys[i].num] = Ans;
    }
}

void solve()
{
    for (int i = 1; i <= q; i++) {
        qys[++qtop] = (qs) {qy[i].r1, qy[i].r2, i, 0};
        if (qy[i].l2 != 1) qys[++qtop] = (qs) {qy[i].r1, qy[i].l2-1, i, 1};
        else ans[i][1] = 0;
        if (qy[i].l1 != 1) qys[++qtop] = (qs) {qy[i].l1-1, qy[i].r2, i, 2};
        else ans[i][2] = 0;
        if (qy[i].l1 != 1 && qy[i].l2 != 1) qys[++qtop] = (qs) {qy[i].l1-1, qy[i].l2-1, i, 3};
        else ans[i][3] = 0;

    }
    solve_q();
    for (int i = 1; i <= q; i++) 
        printf("%lld\n", ans[i][0]-ans[i][1]-ans[i][2]+ans[i][3]);
}

int main()
{
    scanf("%d", &n), sqrtN = ceil(sqrt(n));
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    scanf("%d", &q);
    for (int i = 1; i <= q; i++)
        scanf("%d%d%d%d", &qy[i].l1, &qy[i].r1, &qy[i].l2, &qy[i].r2);
    solve();
    return 0;
}
OIljt12138
关注
专栏目录
湖南师范211大学计算机排名,湖南师范大学认可度怎么样？湖南师范大学在211中的排名如何？...
weixin_36245032的博客
06-22 1395
选择科目测一测我能上哪些大学选择科目领取你的专属报告>选择省份关闭请选择科目确定v>湖南师范大学不仅是211大学，还在2017年入选了世界一流学科建设高校，是湖南省实力不错的师范类大学。那么，湖南师范大学认可度怎么样？湖南师范大学在211中的排名如何？本期，我们就带大家详细了解一下。一、湖南师范大学认可度怎么样？我们将从学校的综合排名，学科及专业实力和学校的就业及升学情况，对湖南师范大...
理科生可以报湖师大计算机系吗,2020湖南师范大学冷门专业排名：湖师大数学系好就业吗？...
weixin_30459905的博客
07-15 933
选择科目测一测我能上哪些大学选择科目领取你的专属报告>选择省份关闭请选择科目确定v>湖南师范大学是湖南省最著名的师范大学，也是曾经的“211大学”之一，现在则入选“双一流”建设高校，属于目前华中地区人气最高的师范院校之一。那么，湖南师范大学冷门专业排名如何？湖师大数学系好就业吗？一、湖南师范大学冷门专业排名以湖南师范大学2019年在湖南本科一批中的录取分数为例，分别筛选出文、理两科中最...
如何在湖师大官网找到考研真题
m0_52592128的博客
05-12 462
在湖师大官网找考研真题资料
2019暑假集训总结与记录
Deep_Kevin的娱乐空间
06-26 713
正题 这个暑假收货颇丰，首先去苏州参加了一个长为12天的NOI集训营，见到了很多大佬，学习了方法，提高了很多，具体可以在搜索框搜索“2019NOI金牌营”，即可以得到许多信息。 还学习了两个比较有用的算法，就是线性代数和原根相关与二次剩余，在我的blog找学习笔记就可以学习相关内容。 后来去了北京，参加了首都师大附中的一个月集训，那里的饭菜是真的好吃（胖了...
南京师范大学计算机等级评估,南师大综合测评标准
weixin_34997593的博客
07-20 1647
南师大综合测评标准 (4页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！19.90 积分1南京南京师师范大学地理科学学院学生范大学地理科学学院学生综综合素合素质测评质测评条例条例( (试试行)行)一、一、总则总则1、为全面正确地贯彻党的教育方针，促进学生综合素质全面提高，根据国家教育部颁布的《普通高等学校学生管理规定》 、 《高等学校学生行为准则》等文...
湖师大信息院推免经验总结
qq_41883610的博客
04-05 1081
湖师大信息院推免经验总结 1.推免资格 2.主要流程 3.前期准备 4.面试准备 1.推免资格 综合推免（成绩保研） 专项推免（竞赛保研） 支教保研（院校主要学生干部） 农硕（必须师范生） 综合推免： 硬性条件：综合成绩前10% 且 通过CET-6 按培养方案要求已修读的公共必修课全部通过；专业课（不含辅修）无补考或重修记录，平均成绩在同年级同专业全体同学中排名位居前20%。（名额分配时基每班前10%） 【2020年信息院综合成绩】 = 90% * 专业课 + 5% * 综测+5% * 竞赛获奖
湖北师范大学专升本历年编程真题（2025年开始湖师大不招专升本了，望周知）
帅气的叶小白的博客
12-19 2530
输入两个正整数 m 和 n，求其最大公约数和最小公倍数。(要求：使用递归函数)输入两个正整数 m 和 n，求其最大公约数和最小公倍数。输入正整数 m，打印 m 以内既是素数又是因数的数。求正整数n之内的所有完数及因子、完数个数。累加和：打印从 m 累加到 n 的和。(要求：使用递归函数)打印九九乘法口诀表。双向选择排序从小到大。
上海师范大学计算机考研难度,上师大考研难吗
weixin_35689019的博客
07-08 1048
需看考生所在区域及备考情况；相比北师大和华东师大，上师大会更好考；如果考生本科学校为中西部地区的非211学校(特别是二区的学校)则不好考(上师大地处上海)，所以是否好考要看和哪个学校比。关键还是看自己的基础和备考情况，因为难易是相对不同的人来说。本科基础好并且备考充分就不难，否则就难；不管是报考哪个学校，务必努力和自信。上海师大是师范类的学校，教育学类的硕士点很多，专业可选范围比较广。教育学院有很...
伊犁师范大学毕业设计课题目录参考
最新发布
杭州.黄老师
07-07 4446
黄菊华老师《Vue.js入门与商城开发实战》《微信小程序商城开发》图书作者，CSDN博客专家，在线教育专家，CSDN钻石讲师；项目的界面和功能都可以定制，包安装运行！所有项目都配有从入门到精通的基础知识视频课程，学习后应对毕业设计答辩。项目配有对应开发文档、开题报告、任务书、PPT、论文模版等。伊犁师范大学校园羽毛球社团报名管理系统。伊犁师范大学校园足球社团报名管理系统。伊犁师范大学校园医务室预约挂号系统。伊犁师范大学校园停车场车位预约系统。伊犁师范大学校园餐厅座位预约系统。
湖南师范大学计算机系宿舍,图文并茂介绍湖南师范大学宿舍 内部真实照曝光...
weixin_42134054的博客
07-19 2790
湖南师范大学分7种学生公寓，宿舍分配是随机制度，大部分都有独卫和空调，有四人间六人间八人间，四人间和六人间是上床下桌，八人间是上下铺。一、师大宿舍分为哪几种?①天马学生公寓②德智园学生公寓③南院学生公寓④江边学生公寓⑤长塘山学生公寓⑥张公岭学生公寓(非本部)⑦师大附中宿舍(不住新生，不介绍)二、师大宿舍是怎么分配的?①师大宿舍分配是随机制度;(注：音体美三院女生大一住旧南院，大二搬入德智园宿舍;男...
2011、2019-2021年湖南师范大学440新闻与传播专业基础考研真题
04-06
该资源为2011、2019-2021年湖南师范大学440新闻与传播专业基础考研真题，资源高清无水印哦！ 该资源为2011、2019-2021年湖南师范大学440新闻与传播专业基础考研真题，资源高清无水印哦！
广西师范大学博士毕业要求.pdf
12-24
广西师范大学的博士毕业要求规定了学术型博士研究生申请博士学位所需的创新成果标准，旨在贯彻全国研究生教育会议精神，落实教育评价改革方案，以及规范学术评价的政策。以下是对这些要求的详细解读： 1. **创新...
陕西师范大学-大学英语三（专升本）考评作业-含答案.pdf
02-03
陕西师范大学-大学英语三（专升本）考评作业-含答案.pdf 本资源是一个陕西师范大学大学英语三（专升本）考评作业，包含答案。该资源共有13个问题，涵盖了大学英语三的多方面内容，包括对话、阅读理解、词汇、语法等...
陕西师范大学-《写作》（专升本）考评作业-含答案.pdf
02-03
陕西师范大学《写作》考评作业知识点总结 I. 语法错误修改部分 1. 语法错误分析：在句子中的语法错误可能来自于词组结构、时态、语态、主谓一致、修饰语位置等方面。例如，句子“He failed to pass the ...
陕西师范大学-《先秦散文研究》（专升本）期末考评作业-含答案.pdf
02-03
陕西师范大学-《先秦散文研究》（专升本）期末考评作业-含答案.pdf 本资源是陕西师范大学《先秦散文研究》课程的期末考评作业，包含答案。该资源涵盖了先秦散文的研究，包括诸子百家、九流十家、法家思想、儒家思想...
关于参加信息竞赛
OIljt12138的博客
09-04 2763
〇、前言 在新生群里安利了不少人熟悉信竞，很开心看到这么多人对于编程&信息竞赛感兴趣。本文将解释信息竞赛的学习内容，知识特点，对于高考的帮助等大家关心的问题。 一、基本情况1. 信息学是什么信息学是一门新兴而古老的学科，对于信息的研究可以追溯到人类使用结绳记事起。文字的诞生、造纸术和印刷术的普及都是信息学研究的阶段性成果，特别是上世纪中叶电子计算机诞生开始，信息学在具体生产生活中发挥着越来越重要
THUWC2018游记
OIljt12138的博客
02-02 2054
THUWC2018游记 Day0 飞机延误了两个小时，不过还好最后飞了…毕竟连续三天都没有飞这个航班。辣鸡南航把飞机座位间距设的贼紧，一路腿麻233 下了飞机发现磁浮快线停运，而且“雅礼洋湖中学”位置贼偏僻，高德规划的最优路径要倒四次车orz。然后先坐机场巴士（其实只有面包车那么大）到了市中心，然后倒了长沙唯一的两个地铁到了一个奇怪的地方…然后决定打车解决问题。 去了一个很nice的酒
[Template]省选复习计划
OIljt12138的博客
04-17 1398
复习计划
某【并不能AC的】模拟题部分解题报告
OIljt12138的博客
10-16 1196
苟利OI生死以，岂因WA避趋之？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值