杂项 List

题目

1. 栈
    #A 表达式的转换 （Unaccepted）

2. STL 模板库

#B 双栈排序（Unaccepted）
    #C 垃圾陷阱（Accepted）
    #D 合并果子（Accepted）
    #E 统计数字（Unaccepted）
    #F 小木棍 ［数据加强版］（Unaccepted）

3. 树状数组

4. 归并排序

#H 逆序对（Unaccepted）

5. 最大子矩形

#A 最大正方形（Unaccepted）
    #B 奶牛浴场（Accepted）
    #C 最大加权矩形（Unaccepted）
    #D [ZJOI2007]棋盘制作 （Unaccepted）

---

1.  棋盘问题

/* Luogu P1549 棋盘问题（2）
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
const int N = ;
int n, m, d[N][N];
bool numlist[N * N];

bool isprime(int x) {
    int sq = sqrt(x);
    for (int i = ; i <= sq; i++)
        if (x % i == ) return false;
    return true;
}

bool dfs(int x, int y, int num) {
    if (x > )
        if (!isprime(num + d[x - ][y])) return false;
    if (y > )
        if (!isprime(num + d[x][y - ])) return false;
    d[x][y] = num; numlist[num] = true;
    if (x == n && y == n) return true;
    int ax = x, ay = y;
    if (ay == n) ay = , ax++; else ay++;
    for (int i = ; i <= n * n; i++)
        if (!numlist[i])
            if (dfs(ax, ay, i)) return true;
    numlist[num] = false;
    return false;
}

int main() {
    scanf("%d", &n);
    if (n == ) { printf("NO\n"); return ; }
    if (dfs(, , )) {
        for (int i = ; i <= n; i++) {
            for (int j = ; j <= n; j++) {
                printf("%d", d[i][j]);
                if (j < n) printf(" ");
            }
            printf("\n");
        }
    }
    else printf("NO\n");
    return ;
}

2. 斐波那契数列

/* Luogu P2626 斐波那契数列（升级版）
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = ; const long long mod = 2147483648ll;
int n, fd[N], pd[N], ptop = ;

int Fibonacci(int x) {
    if (x ==  || x == ) return ;
    if (fd[x]) return fd[x];
    return fd[x] = ((long long) Fibonacci(x - ) + (long long) Fibonacci(x - )) % mod;
}
void PrimeFac(int x) {
    int sq = sqrt(x);
    for (int i = ; i <= sq; i++)
        if (x % i == ) {
            x /= i; pd[ptop] = i; ptop++;
            while (x % i == ) {
                pd[ptop] = i; ptop++;
                x /= i;
            }
        }
    if (x > ) pd[ptop] = x, ptop++;
}

int main() {
    scanf("%d", &n);
    int fb = Fibonacci(n);
    PrimeFac(fb);
    printf("%d=", fb);
    for (int i = ; i < ptop; i++) {
        if (i > ) printf("*");
        printf("%d", pd[i]);
    }
    printf("\n");
    return ;
}

3. 树状数组

/* Fenwick Tree
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
using namespace std;
const int N =  + ;
int n, m, d[N];

inline int lowbit(int x) {
    return x & (-x);
}
inline void modify(int x, int val) {
    while (x <= n) {
        d[x] += val; x += lowbit(x);
    }
}
inline int getsum(int x) {
    int sum = ;
    while (x > ) {
        sum += d[x]; x -= lowbit(x);
    }
    return sum;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = , w; i <= n; i++) {
        scanf("%d", &w); modify(i, w);
    }
    while (m--) {
        int o, x, y;
        scanf("%d%d%d", &o, &x, &y);
        if (o == ) modify(x, y);
        if (o == ) printf("%d\n", getsum(y) - getsum(x - ));
    }
    return ;
}

4. 离散化

/* P2448 无尽的生命
 * 树状数组 + 离散化
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
const int N =  + ;
int n, m, a[ * N], b[ * N], h[ * N], cnt;
ll d[ * N], ans;

struct ques {int x, y;} q[N];

int readint() {
    int a = ; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) {
        a = a *  + c - '';
        c = getchar();
    }
    return a;
}

int find(int x) {
    int l = , r = m;
    while (l <= r) {
        int mid = (l + r) >> ;
        if (h[mid] == x) return mid;
        else if (h[mid] < x) l = mid + ;
        else r = mid - ;
    }
    return r;
}

inline int lowbit(int x) {
    return x & (-x);
}
inline void modify(int x, int val) {
    while (x <= m) {
        d[x] += val; x += lowbit(x);
    }
}
inline ll getsum(int x) {
    ll sum = ;
    while (x) {
        sum += d[x];
        x -= lowbit(x);
    }
    return sum;
}

int main() {
    n = readint();
    for (int i = ; i <= n; i++) {
        a[++cnt] = q[i].x = readint();
        a[++cnt] = q[i].y = readint();
    }
    sort(a + , a + cnt + );
    for (int i = ; i <= cnt; i++)
        if (a[i] != a[i - ]) h[++m] = a[i];

    for (int i = ; i <= m; i++) b[i] = i;
    for (int i = ; i <= n; i++)
        swap(b[find(q[i].x)], b[find(q[i].y)]); 

    modify(b[m], );
    for (int i = m - ; i; i--) {
        ll o = h[i + ] - h[i] - ;
        ll p = getsum(i);
        ans += o * p;
        modify(i, o);
        ans += getsum(b[i] - );
        modify(b[i], );
    }

    printf("%lld\n", ans);
    return ;
}

/* 火柴排队
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;

const int N =  + ;
const int MOD = ;

int n, c[N], d[N];
ll ans;

struct node {
    int num, pos;
    bool operator < (const node &x) const {
        return num < x.num;
    }
} a[N], b[N];

inline int lowbit(int x) {
    return x & (-x);
}
inline void modify(int x, int val) {
    while (x <= n) {
        d[x] += val; x += lowbit(x);
    }
}
inline ll query(int x) {
    ll sum = ;
    while (x) {
        sum += d[x]; x -= lowbit(x);
    }
    return sum;
}

int main() {
    scanf("%d", &n);
    for (int i = ; i <= n; i++)
        scanf("%d", &a[i].num), a[i].pos = i;
    for (int i = ; i <= n; i++)
        scanf("%d", &b[i].num), b[i].pos = i;
    sort(a + , a + n + );
    sort(b + , b + n + );
    for (int i = ; i <= n; i++)
        c[b[i].pos] = a[i].pos;
    for (int i = ; i <= n; i++) {
        modify(c[i], );
        ans = (ans + i - query(c[i])) % MOD;
    }
    printf("%lld\n", ans);
    return ;
}

5. 快速幂

/* P1226 取余运算||快速幂
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n, m, mod;

ll quickpow(int a, int b) {
    ll k = a, tot = ;
    while (b) {
        if (b &  == ) tot = tot * k % mod;
        k = k * k % mod;
        b >>= ;
    }
    return tot;
}

int main() {
    scanf("%d%d%d", &n, &m, &mod);
    printf("%d^%d mod %d=%lld\n", n, m, mod, quickpow(n, m));
    return ;
}

6. 归并排序 （Unaccepted）

7. 二分

/* P2678 跳石头
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
const int N =  + ;
int L, n, m, dis[N], ans;

bool judge(int x) {
    int last = , cnt = ;
    for (int i = ; i <= n + ; i++) {
        if (dis[i] - dis[last] < x) cnt++;
        else last = i;
    }
    if (cnt > m) return false;
    return true;
}

int main() {
    scanf("%d%d%d", &L, &n, &m);
    for (int i = ; i <= n; i++)
        scanf("%d", &dis[i]);
    dis[n + ] = L;

    int l = , r = L, mid;
    while (l <= r) {
        mid = (l + r) >> ;
        if (judge(mid)) l = mid + , ans = mid;
        else r = mid - ;
    }
    printf("%d\n", ans);
    return ;
}

/* P1462 通往奥格瑞玛的道路
 * Au: GG
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <queue>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
const int N =  + , M =  + ;
int n, m; ll d[N];
ll blood, f[N], w[M * ], bin[N];
bool inq[N];
int head[N], nex[M * ], to[M * ], en;
queue<int> q;

void add(int x, int y, int z) {
    nex[++en] = head[x]; head[x] = en; to[en] = y; w[en] = z;
    nex[++en] = head[y]; head[y] = en; to[en] = x; w[en] = z;
}

bool judge(int fn) {
    memset(d, 0x7f, sizeof(d));
    memset(inq, false, sizeof(inq));
    for (int i = ; i <= n; i++)
        if (f[i] > fn) inq[i] = true;
    if (f[] > fn || f[n] > fn) return false;

    q.push(); d[] = ; inq[] = true;

    while (!q.empty()) {
        int a = q.front(); q.pop();
        inq[a] = false;
        for (int b = head[a]; b; b = nex[b])
            if (d[a] + w[b] < d[to[b]]) {
                d[to[b]] = d[a] + w[b];
                if (!inq[to[b]]) {
                    q.push(to[b]);
                    inq[to[b]] = true;
                }
            }
    }
    return d[n] <= blood;
}

int main() {
    int a, b; ll c;
    scanf("%d%d%lld", &n, &m, &blood);
    for (int i = ; i <= n; i++) {
        scanf("%lld", &f[i]);
        bin[i] = f[i];
    }
    for (int i = ; i <= m; i++) {
        scanf("%d%d%lld", &a, &b, &c);
        add(a, b, c);
    }

    sort(bin + , bin + n + );

    int l = , r = n, mid;
    while (l < r) {
        mid = (l + r) >> ;
        if (judge(bin[mid])) r = mid;
        else l = mid + ;
    }
    if (l == r && !judge(bin[l])) printf("AFK\n");
    else printf("%d\n", bin[l]);
    return ;
}