Faraway（HDU-6639）

最新推荐文章于 2019-11-12 20:00:07 发布

原创最新推荐文章于 2019-11-12 20:00:07 发布 · 338 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

HDU 同时被 2 个专栏收录

257 篇文章

订阅专栏

数论——GCD 与 LCM

7 篇文章

订阅专栏

解析一组士兵定位问题，通过分析士兵与未知目标位置的关系，利用数学和编程技巧确定可能的目标位置数量。问题涉及绝对值方程的求解和模运算，通过枚举和区域划分策略寻找解决方案。

Problem Description

n soldiers are dispatched to somewhere in Byteland. These soldiers are going to set off now, but the target location is not so clear.

Assume the target location is at (xe,ye), it is clear that xe,ye are both non-negative integers within [0,m]. For the i-th soldier, the only thing he knows is that (|xi−xe|+|yi−ye|)modki=ti.

To find the correct target location, these soldiers are working on the information they have now. Please write a program to figure out the number of possible target locations.

Input

The first line of the input contains an integer T(1≤T≤10), denoting the number of test cases.

In each test case, there are two integers n,m(1≤n≤10,1≤m≤109) in the first line, denoting the number of soldiers and the upper bound of xe,ye.

For the next n lines, each line contains four integers xi,yi,ki,ti(0≤xi,yi≤m,2≤ki≤5,0≤ti<ki), denoting what each soldier knows.

Output

For each test case, print a single line containing an integer, denoting the number of possible target locations.

Sample Input

2
2 5
1 2 4 2
3 1 2 1
2 5
1 2 4 2
1 2 4 3

Sample Output

10
0

题意：t 组数据，每组有 n 个式子 (|x[i]-x|+|y[i]-y|)%k[i]=t[i]，每组数据给出这个式子的 x[i]、y[i]、k[i]、t[i]，求满足这 n 个的解 {x,y} 的个数，要求 x、y 的范围为 0~m

思路：

对于式子 (|x[i]-x|+|y[i]-y|)%k[i]=t[i] 来说，由于存在绝对值，那么首先要去绝对值

那么每个点 (x[i],y[i]) 会将平面分成 4 个部分，每个部分中的距离表达式都没有绝对值符号，那么就分成了 n^2 个区域

然后枚举每个区域，计算该区域中可能的终点（x[e],y[e]）的数量，由于 1<=k[i]<=5,0<=t[i]<=4，可以发现 LCM(2,3,4,5)=60，因此只需要枚举 x[e]、y[e] 模 60 的余数，然后计算有多少个点即可

Source Program

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<unordered_map>
#include<bitset>
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
#define Pair pair<int,int>
LL quickPow(LL a,LL b){ LL res=1; while(b){if(b&1)res*=a; a*=a; b>>=1;} return res; }
LL multMod(LL a,LL b,LL mod){ a%=mod; b%=mod; LL res=0; while(b){if(b&1)res=(res+a)%mod; a=(a<<=1)%mod; b>>=1; } return res%mod;}
LL quickPowMod(LL a, LL b,LL mod){ LL res=1,k=a; while(b){if((b&1))res=multMod(res,k,mod)%mod; k=multMod(k,k,mod)%mod; b>>=1;} return res%mod;}
LL getInv(LL a,LL mod){ return quickPowMod(a,mod-2,mod); }
LL GCD(LL x,LL y){ return !y?x:GCD(y,x%y); }
LL LCM(LL x,LL y){ return x/GCD(x,y)*y; }
const double EPS = 1E-10;
const int MOD = 998244353;
const int N = 1000+5;
const int dx[] = {-1,1,0,0,1,-1,1,1};
const int dy[] = {0,0,-1,1,-1,1,-1,1};
using namespace std;

int a[N], b[N];
struct Node {
    int x, y, k, t;
} node[N];
bool judge(int x, int y,int n) {
    for (int i = 1; i <= n; i++)
        if ((abs(x - node[i].x) + abs(y - node[i].y)) % node[i].k != node[i].t)
            return 0;
    return 1;
}
int cal(int left, int right) {
    right -= left + 1;
    if (right < 0)
        return 0;
    return right / 60 + 1;
}
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n,m;
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++) {
            scanf("%d%d%d%d", &node[i].x, &node[i].y, &node[i].k, &node[i].t);
            a[i] = node[i].x;
            b[i] = node[i].y;
        }
        a[n+1]=m+1;
        b[n+1]=m+1;
        
        sort(a + 1, a + n + 1 + 1);
        sort(b + 1, b + n + 1 + 1);

        LL res = 0;
        
        for (int i = 0; i <= n; i++) {//分为n^2个区域
            if (a[i] < a[i + 1]) { //防止区域重复
                for (int j = 0; j <= n; j++) {//分为n^2个区域
                    if (b[j] < b[j + 1]) { //防止区域重复
                        for (int x = 0; x < 60; x++) { //枚举终点坐标x的余数
                            for (int y = 0; y < 60; y++) { //枚举终点左边y的余数
                                int ex=a[i]+x;
                                int ey=b[j]+y;
                                if (judge(ex, ey, n)) { // 统计区域中有多少余数
                                    LL ansX=cal(ex,a[i+1]);
                                    LL ansY=cal(ey,b[j+1]);
                                    res += 1LL * ansX *ansY;
                                }
                            }
                        }
                    }
                }
            }
        }
        printf("%lld\n", res);
    }
    return 0;
}