2020ICPC·小米 网络选拔赛第一场

最新推荐文章于 2022-09-30 17:27:13 发布
最新推荐文章于 2022-09-30 17:27:13 发布
阅读量431 收藏
点赞数 3
分类专栏： # 牛客
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44691917/article/details/109372179
版权

比赛链接

前言

第二场都快打了才补完题目发博客，最近事情真的太多了= =

A - Intelligent Warehouse（DP+数论优化），三种做法

题目大意

给出 n n n个数，从中选择最多的数使得选出的集合任何两个数都是倍数关系。

解题思路

任何两个数都是倍数关系也就是说，从第一个数开始，后面的数都是前一个数的倍数即可。显然相同的数贡献就是其数量。那么就是一个简单的 D P DP DP。

做法一：枚举倍数

这题真的无语，一开始就想到了离散化数组然后从小到大（或者从大到小）枚举每个数的倍数，赛时TLE到见鬼，赛后一发过。

//
// Created by Happig on 2020/10/25
//
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define Vector Point
#define ENDL "\n"
#define lowbit(x) (x&(-x))
#define mkp(x, y) make_pair(x,y)
#define mem(a, x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 1e7 + 10;
const int maxm = 2e5 + 10;

int a[maxm], num[maxn];
int d[maxn];

int main() {
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    scanf("%d", &n);
//    clock_t beg = clock();
    int Max = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        //a[i] = i + 1;
        num[a[i]]++;
        Max = max(Max, a[i]);
    }
    sort(a, a + n);
    int m = unique(a, a + n) - a;
    for (int i = m - 1; i >= 0; i--) {
        d[a[i]] = num[a[i]];
        int res = 0;
        for (int j = 2 * a[i]; j <= Max; j += a[i]) {
            if (num[j]) res = max(res, d[j]);
        }
        d[a[i]] += res;
        //cout << d[a[i]] << endl;
    }
    int ans = 0;
    for (int i = 0; i < m; i++) {
        ans = max(ans, d[a[i]]);
    }
    printf("%d\n", ans);
//    clock_t ed = clock();
//    cout << ed - beg << endl;
    return 0;
}

做法二：枚举范围内所有数的素数倍

据说这是题解给出的做法，因为所有数的范围只有 1 e 7 1e7 1e7，那么我们枚举所有的数，只向其素数倍转移即可，时间复杂度我不会证明，据说是 O ( w log ⁡ log ⁡ w ) O(w \log \log w) O(wloglogw)。

//
// Created by Happig on 2020/10/25
//
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define Vector Point
#define ENDL "\n"
#define lowbit(x) (x&(-x))
#define mkp(x, y) make_pair(x,y)
#define mem(a, x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 1e7 + 10;
const int maxm = 2e5 + 10;

int prime[maxn / 2];
bitset<maxn> vis;
int cnt;

void euler() {
    cnt = 0;
    vis.reset();
    for (int i = 2; i < maxn; i++) {
        if (!vis[i]) prime[++cnt] = i;
        for (int j = 1; j <= cnt && 1LL * i * prime[j] < maxn; j++) {
            vis[i * prime[j]] = 1;
            if (i % prime[j] == 0) break;
        }
    }
}

int d[maxn], num[maxn];

int main() {
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    euler();
    int n, Max = 0;
    scanf("%d", &n);
    for (int i = 0, x; i < n; i++) {
        scanf("%d", &x);
        ++num[x], Max = max(Max, x);
    }
    int ans = 0, N = 1e7;
    for (int i = 1; i <= N; i++) {
        d[i] += num[i];
        for (int j = 1; j <= cnt && 1LL * prime[j] * i <= Max; j++) {
            int k = prime[j] * i;
            d[k] = max(d[k], d[i]);
        }
        ans = max(ans, d[i]);
    }
    printf("%d\n", ans);
    return 0;
}

做法三：质因数分解

这是赛时想到的毒瘤做法，只是比较耗空间，在 P o l l a r d − R h o Pollard-Rho Pollard−Rho质因数分解那里提到的时间复杂度只有 O ( n 0.25 ) O(n^{0.25}) O(n0.25)，而且递归搜索所有因数也是常数时间复杂度，因此我们考虑质因数分解，我本地测试，分解 2 e 5 2e5 2e5个 1 e 7 1e7 1e7范围的数，耗时 380 m s 380ms 380ms，实际上证明了这种因数分解的做法是跑的飞快的。那么在做法一中，我们改为枚举所有数的因数倍，这样成功卡过赛时的辣鸡评测机。


//
// Created by Happig on 2020/10/25
//
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define Vector Point
#define ENDL "\n"
#define lowbit(x) (x&(-x))
#define mkp(x, y) make_pair(x,y)
#define mem(a, x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 1e7 + 10;
const int maxm = 2e5 + 10;

int prime[maxn / 2], p[maxn], num[1005], pfac[1005];
int cnt1, cnt2, tot;

void euler() {
    cnt1 = 0;
    for (int i = 1; i < maxn; i++) p[i] = i;
    for (int i = 2; i < maxn; i++) {
        if (p[i] == i) prime[++cnt1] = i;
        for (int j = 1; j <= cnt1 && 1LL * i * prime[j] < maxn; j++) {
            p[i * prime[j]] = prime[j];
            if (i % prime[j] == 0) break;
        }
    }
}

void divide(int n) {
    cnt2 = 0;
    while (n != 1) {
        pfac[++cnt2] = p[n];
        n /= p[n];
    }
    sort(pfac + 1, pfac + 1 + cnt2);
    tot = 1, num[tot] = 1;
    for (int i = 2; i <= cnt2; i++) {
        if (pfac[i] == pfac[i - 1]) {
            num[tot]++;
        } else {
            num[++tot] = 1;
            pfac[tot] = pfac[i];
        }
    }
}

vector<int> fac[maxm];
int pos;

void dfs(int d, ll cur = 1) {
    if (d == tot + 1) {
        fac[pos].push_back(cur);
        return;
    }
    for (int i = 0; i <= num[d]; i++) {
        dfs(d + 1, cur);
        cur *= pfac[d];
    }
}

int a[maxm], vis[maxn], d[maxn];

int main() {
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
//    clock_t beg = clock();
    euler();
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        vis[a[i]]++;
    }
    sort(a, a + n);
    int m = unique(a, a + n) - a;
    for (int i = 0; i < m; i++) {
        divide(a[i]);
        pos = i;
        dfs(1, 1);
    }
    int ans = 0;
    for (int i = 0; i < m; i++) {
        d[a[i]] = vis[a[i]];
        int res = 0;
        for (auto j:fac[i]) {
            if (vis[j] && j != a[i]) res = max(res, d[j]);
        }
        d[a[i]] += res;
        //cout << a[i] << " " << d[a[i]] << endl;
        ans = max(ans, d[a[i]]);
    }
    printf("%d\n", ans);
    return 0;
}
B - Intelligent Robot（计算几何+最短路）

题目大意

在表格中给出起点和终点，但是在路径上可能分布着很多墙，墙用线段表示，墙不能穿过但是可以紧贴，问从起点到终点的最短路径的长度是多少。

解题思路

这题一看就特别眼熟，原来在kuangbin的计算几何基础专题中有道非常相似的 P O J 1556 POJ1556 POJ1556，当时做那道题收获就很大所以还记得做法。这个做法的前提是证明当墙挡住路的时候，无论如何从墙的端点处绕路总是最优的。那么我们将所有点存起来，所有线段存起来，枚举任意两点和所有线段判断是否相交，如果相交两点距离设为 i n f inf inf，这样就能建一张图，最后对图跑最短路算法即可，因为点数很少，直接上 F l o y d Floyd Floyd是最快的。



//
// Created by Happig on 2020/10/25
//
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define Vector Point
#define Seg Line
#define ENDL "\n"
#define lowbit(x) (x&(-x))
#define mkp(x, y) make_pair(x,y)
#define mem(a, x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 1e7 + 10;
const int maxm = 2e5 + 10;

int dcmp(double d) {
    if (fabs(d) < eps) return 0;
    if (d < 0) return -1;
    return 1;
}

struct Point {
    double x, y;

    Point(double a = 0, double b = 0) {
        x = a, y = b;
    }

    Point operator+(Point p) { return Point(x + p.x, y + p.y); }

    Point operator-(Point p) { return Point(x - p.x, y - p.y); }

    Point operator*(double d) { return Point(x * d, y * d); }

    double operator*(Point p) { return x * p.x + y * p.y; }

    Point operator/(double d) { return Point(x / d, y / d); }

    double operator^(Point p) { return x * p.y - y * p.x; }

    bool operator==(const Point &p) const { return x == p.x && y == p.y; }

    void print() { printf("(%.2lf,%.2lf)\n", x, y); }
};

struct Line {
    Point p, q;
    Vector v;

    Line() {}

    Line(Point a, Point b) {
        p = a, q = b, v = b - a;
    }

    Point point(double t) {
        return p + v * t;
    }
};

double dis(Point a, Point b) {
    return sqrt((b - a) * (b - a));
}

bool isSegInter(Seg a, Seg b) {
    double c1 = a.v ^b.p - a.p, c2 = a.v ^b.q - a.p;
    double c3 = b.v ^a.p - b.p, c4 = b.v ^a.q - b.p;
    return (dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0);
}

bool vis[610][610];   //判断两点之间是否能直接相连
double G[615][615];  //存两点间的距离，初始根据vis数组初始化为两点间距离
Point P[1005];        //保存所有点
Line walls[305];
int Path[610][610];

void Print(int u, int v) {
    if (u == v) {
        printf("%d\n", v); 
        return;
    }
    printf("%d ", u);
    Print(Path[u][v], v);
}

int main() {
    double a, b, c, d;
    int n, m, K;
    scanf("%d%d%d", &n, &m, &K);
    for (int i = 1; i <= K; i++) {
        scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
        P[i] = Point(a, b), P[K + i] = Point(c, d);
        walls[i] = Line(P[i], P[K + i]);
    }
    scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
    P[0] = Point(a, b), P[2 * K + 1] = Point(c, d);  //起点终点

    memset(vis, 0, sizeof(vis));
    for (int i = 0; i <= 2 * K + 1; i++) {
        for (int j = 0; j <= 2 * K + 1; j++) {
            int flag = 1;
            if (i == j) {
                G[i][j] = 0;
                continue;
            } //这里初始化到本身距离为0

            for (int h = 1; h <= K; h++) {
                if (isSegInter(Line(P[i], P[j]), walls[h])) {
                    flag = 0;
                    break;
                }
            }

            if (flag) vis[i][j] = 1;
        }
    }


    //对于能相连的点调用距离公式，否则为INF
    for (int i = 0; i <= 2 * K + 1; i++) {
        for (int j = 0; j <= 2 * K + 1; j++) {
            Path[i][j] = j;
            if (vis[i][j]) G[i][j] = dis(P[i], P[j]);
            else G[i][j] = INF;
//            printf("%.1lf ", G[i][j]);
//            printf("%d", vis[i][j]);
        }
//        printf("\n");
    }

    for (int k = 0; k <= 2 * K + 1; k++) {
        for (int i = 0; i <= 2 * K + 1; i++) {
            for (int j = 0; j <= 2 * K + 1; j++) {
                if (G[i][k] + G[k][j] < G[i][j]) {
                    G[i][j] = G[i][k] + G[k][j];
                    Path[i][j] = Path[i][k];
                }
            }
        }
    }
    
    printf("%.4lf\n", G[0][2 * K + 1]);
//    Print(0, 2 * K + 1);
    return 0;
}
C - Smart Browser（签到）

代码就不放了，毕竟有手就行（逃

D - Router Mesh（Tarjan）

图论队友赛时当场学习，结果WA了无数发过不了。补上代码：

//
// Created by Visors on 2020/10/25.
//
// 题目名：TODO
// 题目来源：TODO
// 题目链接：TODO
// 算法：D.cpp
// 用途：TODO
// 时间复杂度：O(TODO)
//

#include <bits/stdc++.h>

using namespace std;

int block = 0;

struct Tarjan {
    struct Edge {
        int to, next;

        Edge() = default;

        Edge(int to, int next) : to(to), next(next) {}
    };

    int vertexNum{}, edgeNum{};
    int cnt{};              // 当前时间戳
    int root{};             // 保存当前搜索树根
    vector<Edge> edges;
    vector<int> heads;
    vector<int> dfn;        // 时间戳
    vector<int> low;        // 最早追溯时间
    vector<bool> isCut;     // 割点
    vector<int> branches;   // 分支数
//    set<int> cuts;          // 割点编号集

    void init(int n, int m) {
        cnt = 0;
        vertexNum = n;
        edgeNum = m;
        heads.resize(vertexNum);
        fill(heads.begin(), heads.end(), -1);
        dfn.resize(vertexNum);
        low.resize(vertexNum);
        isCut.resize(vertexNum);
        branches.resize(vertexNum);
    }

    void addEdge(int u, int v) {
        edges.emplace_back(v, heads[u]);
        heads[u] = edges.size() - 1;
    }

    void dfs(int u) {
        dfn[u] = low[u] = ++cnt;
        int tot = 0;
        for (int i = heads[u]; ~i; i = edges[i].next) {
            int &v = edges[i].to;
            if (!dfn[v]) {
//                branches[u]++;
                dfs(v);
                low[u] = min(low[u], low[v]);
                if (low[v] >= dfn[u]) {
                    tot++;
                    if (u != root || tot > 1) isCut[u] = true;   // 对树根特判
                }
            } else low[u] = min(low[u], dfn[v]);
        }
        if (u != root) tot++;
        branches[u] = tot;
    }

    void run() {
        for (int i = 0; i < vertexNum; i++)
            if (!dfn[i]) {
                root = i;
                block++;
                dfs(i);
            }
    }
} tarjan;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int n, m;
    cin >> n >> m;
    tarjan.init(n, m);
    for (int i = 1, u, v; i <= m; i++) {
        cin >> u >> v;
        u--, v--;
        tarjan.addEdge(u, v);
        tarjan.addEdge(v, u);
    }
    tarjan.run();
    bool first = true;
    for (int i = 0; i < n; i++) {
//        cout << endl << tarjan.branches[i] << endl;
        if (first) {
            cout << block + tarjan.branches[i] - 1;
            first = false;
        } else cout << ' ' << block + tarjan.branches[i] - 1;
    }
    cout << endl;
    return 0;
}
F- Design Problemset（二分答案）

这题队友补的，我就没看了，只放下代码

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;

const int maxn=1e5+5;

ll a[maxn],l[maxn],r[maxn];
ll k,L,R;
bool check(double mid)
{
    //cout<<"mid "<<mid<<endl;
    if(mid==0)
        return 1;
    double tot=0;double res=0;
    for(int i=1;i<=k;i++)
    {
        if(double(mid*l[i])>a[i])
            return 0;
        ll num=a[i]/mid;//讲第i种问题分成mid组，每组的数量是多少
        num=min(r[i],num);//第i种问题最多可以取的数量,
        //如果该种问题取的是r【i】，即使还有平分后剩余也不能再用
        if(num!=r[i])
            res+=a[i]-num*mid;
        tot+=num;
    }
    tot+=res/mid;
    if(tot>=L)
        return true;
    return false;
}
int main()
{
    
    cin>>k>>L>>R;
    for(int i=1;i<=k;i++)
           cin>>a[i];
    for(int i=1;i<=k;i++)
        cin>>l[i]>>r[i];
    ll cntl=0,cntr=0;
    for(int i=1;i<=k;i++)
        cntl+=l[i],cntr+=r[i];
    if(cntl>R || cntr<L)
    {
        cout<<0<<'\n';
        return 0;
    }
        
    ll lt=0,rt=1e18+5;
    ll ans;
    while(rt-lt>0)
    {
        ll mid=(rt+lt+1)>>1;
        if(check(mid))
             lt=mid;
        else rt=mid-1;
    }
    cout<<lt<<'\n';
    return 0;
}
I - Walking Machine（搜索）

这题应该也是签到，队友写的

//
// Created by Visors on 2020/10/25.
//
// 题目名：TODO
// 题目来源：TODO
// 题目链接：TODO
// 算法：I.cpp
// 用途：TODO
// 时间复杂度：O(TODO)
//

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;

const int N = 1005, M = 1005;

char G[N][M];
bool book[N][M];
int n, m;
int ans = 0;
queue<pii> q;
int dir[4][2] = {{0, 1},
                 {0, -1},
                 {1, 0},
                 {-1, 0}};
char check[4] = {'A', 'D', 'W', 'S'};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            cin >> G[i][j];
            if (i == 1 || i == n || j == 1 || j == m) {
                if (i == 1) {
                    if (j == 1 && (G[i][j] == 'A' || G[i][j] == 'W')) {
                        q.emplace(i, j);
                        book[i][j] = true;
                        continue;
                    }
                    if (j == m && (G[i][j] == 'D' || G[i][j] == 'W')) {
                        q.emplace(i, j);
                        book[i][j] = true;
                        continue;
                    }
                    if (G[i][j] == 'W') {
                        q.emplace(i, j);
                        book[i][j] = true;
                    }
                    continue;
                }
                if (i == n) {
                    if (j == 1 && (G[i][j] == 'A' || G[i][j] == 'S')) {
                        q.emplace(i, j);
                        book[i][j] = true;
                        continue;
                    }
                    if (j == m && (G[i][j] == 'D' || G[i][j] == 'S')) {
                        q.emplace(i, j);
                        book[i][j] = true;
                        continue;
                    }
                    if (G[i][j] == 'S') {
                        q.emplace(i, j);
                        book[i][j] = true;
                    }
                    continue;
                }
                if (j == 1 && G[i][j] == 'A') {
                    q.emplace(i, j);
                    book[i][j] = true;
                    continue;
                }
                if (j == m && G[i][j] == 'D') {
                    q.emplace(i, j);
                    book[i][j] = true;
                }
            }
        }
    pii tmp;
    while (!q.empty()) {
        tmp = q.front();
        ans++;
        int &x = tmp.first,
                &y = tmp.second;
        q.pop();
        for (int i = 0, nx, ny; i < 4; i++) {
            nx = x + dir[i][0];
            ny = y + dir[i][1];
            if (x > 0 && x <= n && y > 0 && y <= m && G[nx][ny] == check[i] && !book[nx][ny]) {
                q.emplace(nx, ny);
                book[nx][ny] = true;
            }
        }
    }
    cout << ans << endl;
    return 0;
}
J - Matrix Subtraction（二维差分）

题目大意

给出一个矩阵，现在还有一个大小一定且可以在大矩阵内随意移动的子矩阵，每次可以对子矩阵内的所有数都减一，问大矩阵最后能否都减为 0 0 0。

解题思路

不难想到如果最终都能减为 0 0 0，无论从哪个位置出发开始减都是可以的，那么我们考虑从右上角出发，每次减去最小的元素，如果存在某个元素被减后小于 0 0 0显然无法完成。这个过程明显是二维差分，时间复杂度 O ( n m ) O(nm) O(nm)。


//
// Created by Happig on 2020/10/27
//
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define Vector Point
#define ENDL "\n"
#define lowbit(x) (x&(-x))
#define mkp(x, y) make_pair(x,y)
#define mem(a, x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double dinf = 1e300;
const ll INF = 1e18;
const int Mod = 1e9 + 7;
const int maxn = 2e5 + 10;

int p[1005][1005], d[1005][1005];
int T, n, m, a, b;

void add(int i, int j, int x, int y, int val) {
    d[i][j] += val, d[x + 1][y + 1] += val;
    d[x + 1][j] -= val, d[i][y + 1] -= val;
}

void print() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cout << d[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> T;
    while (T--) {
        cin >> n >> m >> a >> b;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                cin >> p[i][j];
                d[i][j] = p[i][j] - p[i - 1][j] - p[i][j - 1] + p[i - 1][j - 1];
            }
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                d[i][j] = d[i][j] + d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
                if (d[i][j] < 0) {
                    goto fail;
                } else if (d[i][j] > 0) {
                    if (i + a - 1 > n || j + b - 1 > m) goto fail;
                    else add(i, j, i + a - 1, j + b - 1, -d[i][j]);
                }
            }
        }

        cout << "^_^" << ENDL;
        continue;
        fail:
        cout << "QAQ" << ENDL;
    }
    return 0;
}
Happig丶
关注
专栏目录
2020ICPC·小米 网络选拔赛第一场 全部题解
繁凡さん的博客
10-27 1677
题目情况 A 题：数论 + 动态规划 B 题：计算几何 + 最短路 C 题：模拟 D 题：图论（连通块个数） E 题：略 F 题：二分答案 G 题：图论 H 题：略 I 题：搜索（BFS）/ 并查集 J 题：二维前缀和 + 二维差分 K 题：数学（难） A、 Intelligent Warehouse 题目大意: 给你一个序列,让你选出最多的数,使得选中的数之间互为倍数(aia_iai​是aja_jaj​的倍数或者aja_jaj​是aia_iai​的倍数)
ICPC-2022网络赛第二场
GrittyB的博客
09-29 838
首先, 对于一个满足条件的区间, 若确定最小值x , 那么该区间内的数字一定是 [x ~ x + len - 1] , 也就是方案数 = len!排完序后访问, l 一定是刚好包括的, 如果 r 也被包括了, 那么就是这个区间, 如果r 没有被包括, 就pop, 直到找到刚好满足的。给一个长度为n的字符串 在字符串内只有 I,C,P 三个字符，有 Q 次询问，每次询问某两个区间内为ICPC的子序列有多少个?第i行, 是将序列 a[1…是 该题的一个单位元, 也就是说, 1%p, 10%p , …
2020ICPC·小米 网络选拔赛第一场题解（D，J）
画船听雨眠
10-28 730
链接：https://ac.nowcoder.com/acm/contest/7501 来源：牛客网 A 签到题 D-Router Mesh 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld judge：牛客竞赛 In a Mesh networking system, there are nnn MI Routers, where mmm pairs of MI Routers are bidirecti
2020ICPC·小米 网络选拔赛热身赛-A.ABBA
随风而行的博客
10-25 785
地址：https://ac.nowcoder.com/acm/contest/8409/A 思路：动态规划或组合数学 思路一，动态规划： 思路二，组合数学：
2020.9.19 ICPC网络选拔赛 第一场
Icey_dying的博客
09-20 314
A，F，H，I，K
2020ICPC·小米 网络选拔赛第一场 D Tarjin
weixin_45784984的博客
10-28 130
D-Router Mesh 代码一写就会，再写就忘了 这题一看，跟我最近学的求割点好像，考虑一堆，删除单独成块的点块总数-1，删除块里的点分俩，非割点总块不增减，割点删后块数+1（后来WA了一发后想到删割点增加块数可能比1多，然后就不知道怎么操作了） 链式前向星建图，背模板吧，习惯到0结束（边数组开俩倍大） ans[i]表示删去i点后增加多少块，在求割点算法标记为1的基础上修改 如果该点不是根节点的话，ans为1 望有不抄模板的能力吧 struct team { int to,next; }edge
ACM-ICPC 2020年上海区域赛正式赛试题
12-16
【ACM-ICPC 2020年上海区域赛正式赛试题】是国际大学生程序设计竞赛（ICPC）的一部分，由国际计算机协会（ACM）主办，旨在考验参赛大学生的创新思维、团队协作和在高压环境下编程、分析问题及解决问题的能力。...
2019ICPC印尼网络赛.rar
10-06
《2019ICPC印尼网络赛：编程竞赛的魅力与挑战》 国际大学生程序设计竞赛（International Collegiate Programming Contest，简称ICPC）是一项全球性的计算机编程竞赛，旨在推动大学计算机科学教育的发展，培养学生的...
ICPC2021第一场网络预选赛A题
weixin_47278759的博客
09-20 916
ICPC2021第一场网络预选赛A题 A题题意大概就是有n台机器，有m个待运行的程序，输入会给定机器数量，还有每个程序的到达时间和运行时间，求所有处理程序最多的机器，按机器下标排输出。 ps(第i个程序到达时会从第i%n台机器开始寻找第一台空闲机器，那么就是从i%n - n 寻找第一台空闲机器，如果没有空闲机器，就从1 - （i%n - 1）寻找，若所有机器都不空闲，则此程序丢弃） 解题思路：从题意我们可以解析出每个程序其实是在i%n - n 和1 - (i%n - 1) 两个区间寻找第一台空闲机器，
2020ICPC·小米 网络选拔赛第一场 Router Mesh
TheSunspot的博客
12-28 171
题目链接 https://ac.nowcoder.com/acm/contest/7501 题意 求出图中删去每个点后联通块数目 思路 tarjan算法求割点修改 维护dfn和low数组，对于边u-v，如果low[v]>=dfn[u]，说明只可以通过u到达v，u是割点，删除u会增加一个连通数，那我们记录增加的连通数个数，记为tmp。当u不是树根时，删点后父亲也是一个分量，那么删去后联通块数目从1变到了tmp+1，如果是树根，则是从1变到了tmp。我们记变成的联通块个数为ans。那么对于删去的每个点，联
2020ICPC·小米 网络选拔赛热身赛
Dejavu的博客
11-06 350
B 题意描述 思路 对于每个数字，我们求出它的贡献。 以1,2,1,31,2,1,31,2,1,3为例。 a[1]a[1]a[1]在[1,1],[1,2],[1,3],[1,4][1,1],[1,2],[1,3],[1,4][1,1],[1,2],[1,3],[1,4]中出现，且出现了444次，贡献为1∗41*41∗4； a[2]a[2]a[2]在[2,2],[2,3],[2,4],[1,2],[1,3],[1,4][2,2],[2,3],[2,4],[1,2],[1,3],[1,4][2,2],[2,3
2020ICPC·小米 网络选拔赛热身赛 I-Integration
狙击美佐的博客
10-24 446
2020ICPC·小米 网络选拔赛热身赛 I-Integration 裂项+待定系数+找规律题意思路Code 传送门：https://ac.nowcoder.com/acm/contest/8409/I 题意 求解∫0+∞1∏i=1n(ai2+x2)dx求解\int_{0}^{+\infty }\frac{1}{\prod_{i=1}^n(a_i^2+x^2)}dx求解∫0+∞​∏i=1n​(ai2​+x2)1​dx 思路 想要用分部积分求该定积分是非常非常困难的，而题目给出了∫0+∞11+x2dx=π2，
2020ICPC·小米 网络选拔赛第一场 Walking Machine 并查集
幸愉编程·信奥编程私教1v1
10-30 132
Walking Machine 题目大题 在一个 n∗mn*mn∗m 的矩阵中搜索，每个字符有不同的含义，比如： WWW 表示从(xxx,yyy)可以走到 (x−1x-1x−1,yyy) AAA 表示从(xxx,yyy)可以走到 (xxx,y−1y-1y−1) SSS 表示从(xxx,yyy)可以走到 (x+1x+1x+1,yyy) DDD 表示从(xxx,yyy)可以走到 (xxx,y+1y+1y+1) 请求出哪些点会越界，即点坐标(xxx,yyy) xxx < 1 或者 xxx > nnn，
2020ICPC(小米邀请赛1) - Phone Network(线段树优化递推)
Falcon的博客
10-27 344
题目链接：点击查看 题目大意：给出一个长度为 n 的数列，每个数的取值范围是 [ 1 , m ]，题目保证了每个数至少出现过一次，现在对于 i ∈ [ 1 , m ] ，分别输出在原数列中，包含了 [ 1 , i ] 的所有种类数字的最短长度 题目分析：刚着手时想了很多做法，但都不能通过数据结构优化到合适的时间复杂度，比如 O( m ) 枚举数字，每次 O( n ) 去尺取，亦或是 O( m ) 枚举数字，然后二分长度去 check，越想越离谱。。 其实这个题目已经在提示需要往递推的方面去想了，先放上
[含证明][平面几何]2021icpc第一场网络选拔赛F Land Overseer
Cloth的博客
09-23 406
The role of Keqing, Yuheng of the Liyue Qixing, is to manage real estate and construction in Liyue. Today Keqing decides to leave her office, and visit two places - Chasm, and Jueyun Karst - to make sure the building progress there is at a reasonable pace
2019 acm-icpc 北美选拔赛
cosx_的博客
03-21 204
2021年度训练联盟热身训练赛第三场 A 题 用栈模拟一遍就够了 #include<bits/stdc++.h> using namespace std; int a[30]; char c; stack <int> s; int main() { int n; cin >> n; for(int i = 0; i < n; ++i) { cin >> c; if(c == 'T') a[i] = 1; } while(cin &gt
2020ICPC(小米邀请赛2) - 2020(二分+贪心)
Falcon的博客
11-03 390
题目链接：点击查看 题目大意：给出一个长度为 n 的字符串，问最多可以匹配多少个互不相交的 “2020”的子序列 题目分析：考虑 “2020” 是由两个 “20” 组成的，假设对于一个 “20” 来说，用 ( l , r ) 来表示其在字符串中覆盖的起止位置，那么用来组成 “2020” 的两个 “20”：( l1 , r1 ) , ( l2 , r2 )，必须满足 r1 < l2 或 r2 < l1 才行，也就是互不相交 假设现在有 k 个 “2020”，也就是需要选择 2 * k 个 .
2022 ICPC网络预选赛1
最新发布
supreme567的博客
09-30 1653
2022 ICPC网络预选赛1
2013 ACM_ICPC 南京赛区网络赛：编程挑战
"2013 ACM_ICPC 南京赛区网络赛题目包含了多个算法和编程挑战，涵盖了不同的计算机科学领域。 1. ProblemA - Area 该问题可能涉及到几何计算，要求参赛者编写程序来计算特定区域。描述部分可能包含如何处理几何形状...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值