两点之间 这题有毒啊,不会做

https://biancheng.love/problem/640/index

一直re

不是并查集吗

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <assert.h>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;

#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
const int maxn = 1e6 + 20;
const LL MOD = 10007;
int n, m, q;
string str[maxn];
int fa[maxn];
int Size[maxn];
int first[MOD + 20];
int num;
void init(int tot) {
    for (int i = 0; i <= MOD; ++i) {
        fa[i] = i;
        Size[i] = 1;
    }
    memset(first, 0, sizeof first);
    num = 0;
}
struct node {
    LL val;
    int id;
    int u;
    int tonext;
} e[maxn * 2];
void add(int x, int y) {
    ++num;
    e[num].val = 1LL * x * 1000000 + y;
    assert(e[num].val >= 0);
    e[num].id = num;
    e[num].u = e[num].val % MOD;
    e[num].tonext = first[e[num].u];
    first[e[num].u] = num;
}
int tohash(int x, int y) {
    LL val = 1LL * x * 1000000 + y;
    int u = val % MOD;
    for (int i = first[u]; i; i = e[i].tonext) {
        if (e[i].val == val) return e[i].id;
    }
    while(1);
//    assert(false);
}
int tofind(int x) {
    if (fa[x] == x) return x;
    else return fa[x] = tofind(fa[x]);
}
void tomerge(int x, int y) {
    x = tofind(x);
    y = tofind(y);
    if (x != y) {
        fa[y] = x;
        Size[x] += Size[y];
    }
}
int tonext[4][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}};
struct data {
    int val, fa;
} gg[12];
void work() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; ++i) {
        scanf("%s", str[i].c_str() + 1);
    }
    init(n * m);
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            add(i, j);
        }
    }
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (i - 1 >= 1 && str[i - 1][j] == str[i][j]) {
                int x = tofind(tohash(i, j));
                int y = tofind(tohash(i - 1, j));
                tomerge(x, y);
            }
            if (j - 1 >= 1 && str[i][j - 1] == str[i][j]) {
                int x = tofind(tohash(i, j - 1));
                int y = tofind(tohash(i, j));
                tomerge(x, y);
            }
        }
    }
    while (q--) {
        int x, y;
        scanf("%d%d", &x, &y);
        memset(gg, 0, sizeof gg);
        int ans = Size[tofind(tohash(x, y))];
        for (int i = 0; i < 4; ++i) {
            int tx = x + tonext[i][0];
            int ty = y + tonext[i][1];
            if (tx >= 1 && tx <= n && ty >= 1 && ty <= m) {
                int father = tofind(tohash(tx, ty));
                if (gg[str[tx][ty] - ‘0‘].fa == father) continue;
                gg[str[tx][ty] - ‘0‘].val += Size[father];
                gg[str[tx][ty] - ‘0‘].fa = father;
            }
        }
        int id = str[x][y];
        for (int i = 0; i < 4; ++i) {
            int tx = x + tonext[i][0];
            int ty = y + tonext[i][1];
            if (tx >= 1 && tx <= n && ty >= 1 && ty <= m) {
//                int father = tofind(tohash(tx, ty));
                if (ans < gg[str[tx][ty] - ‘0‘].val) {
                    ans = gg[str[tx][ty] - ‘0‘].val;
                    id = str[tx][ty];
                } else if (ans == gg[str[tx][ty] - ‘0‘].val) {
                    if (id == str[x][y]) {
                        id = str[tx][ty];
                    }
                }
            }
        }
        printf("%d\n", ans + (id != str[x][y]));
    }
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    while (t--) work();
    return 0;
}

时间: 2024-11-28 23:19:49

两点之间 这题有毒啊,不会做的相关文章

两点之间最短路径:弗洛伊德算法

弗洛伊德算法是计算无向有权图中两点间最短路径的算法,复杂度为O(n^3).其思路是将两点间距离分为过(指定的)第三点或是不过,然后取它们的最小值,如此循环就可以得到两点之间真正的最小值. void floyd() { for (int k = 0; k < n; ++k) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { //在当前i到j经过k点的路径与直连的路径中选最短 matrix[i][j] = min(ma

利用结构类型的相关知识计算两点之间的距离

#include<stdio.h>#include<stdlib.h>#include<math.h> struct point{ /*点的结构类型名*/ float x; /*横坐标*/ float y; /*纵坐标*/ }; struct point readPoint(); /*函数原型声明*/float distance(struct point p1,struct point p2);/*主函数*/ int main(void){ struct point a

2D和3D空间中计算两点之间的距离

自己在做游戏的忘记了Unity帮我们提供计算两点之间的距离,在百度搜索了下. 原来有一个公式自己就写了一个方法O(∩_∩)O~,到僵尸到达某一个点之后就向另一个奔跑过去 /// <summary> /// 3维中如何计算两点之间的距离 /// </summary> /// <param name="p1"></param> /// <param name="p2"></param> /// &l

C#面向对象思想计算两点之间距离

题目为计算两点之间距离. 面向过程的思维方式,两点的横坐标之差,纵坐标之差,平方求和,再开跟,得到两点之间距离. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Classes_2_point_distance { class Program { static void Main(string[

计算两点之间的角度的代码

+ ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 /// 离心率 /// 返回两点间的角度 private double PointToAngle(Point AOrigin, Point APoint, double AEccentricity) { if (APoint.X == AOrigin.X) if (APoint.Y > AOrigin.Y) return Math.PI * 0.5;

蓝桥--危险系数(求两点之间的割点个数)

历届试题 危险系数 时间限制:1.0s   内存限制:256.0MB 问题描述 抗日战争时期,冀中平原的地道战曾发挥重要作用. 地道的多个站点间有通道连接,形成了庞大的网络.但也有隐患,当敌人发现了某个站点后,其它站点间可能因此会失去联系. 我们来定义一个危险系数DF(x,y): 对于两个站点x和y (x != y), 如果能找到一个站点z,当z被敌人破坏后,x和y不连通,那么我们称z为关于x,y的关键点.相应的,对于任意一对站点x和y,危险系数DF(x,y)就表示为这两点之间的关键点个数. 本

hdu3534 树形dp(求树中两点之间的最大距离)

http://acm.hdu.edu.cn/showproblem.php?pid=3534 Problem Description In the Data structure class of HEU, the teacher asks one problem: How to find the longest path of one tree and the number of such longest path? Input There are several test cases. The

openlayer3计算两点之间的距离

openlayer3计算两点之间的距离 对应的openlayers的版本为3.7. 主要用的接口是ol.Sphere.haversineDistance([x1,y1],[x2,y2]): 4326坐标系中计算两点距离的方式为: var wgs84Sphere = new ol.Sphere(6378137); wgs84Sphere.haversineDistance(C1,C2); 示例为: var wgs84Sphere = new ol.Sphere(6378137); wgs84Sph

两点之间线段最短,事实真是这样吗?

从小,大人们就告诫我们过马路要直线穿过去,而不要斜插过去,因为这样距离短,就避免了危险.这似乎也印证着两点之间线段最短这句话,同时我也坚信着,两点之间走直线时间最短.直到我见到了下面这张图. 经过无数学霸的论证和科学实验,上图红色路线是最快的路线,此曲线也因此被称为"最速曲线".颠覆思维的一张图,在生活中会给我们什么启示呢? "内圣外王"-做人做事之道 "水至清则无鱼,人至察则无徒",生活中,我们避免不了与人打交道,如果为人太刚硬,太特立独行,势