技術標籤：演算法pythonjavac++c語言

傳送門

[NOI2015]程式自動分析

題目描述

在實現程式自動分析的過程中，常常需要判定一些約束條件是否能被同時滿足。

考慮一個約束滿足問題的簡化版本：假設 \(x_1,x_2,x_3,\cdots\) 代表程式中出現的變數，給定 \(n\) 個形如 \(x_i=x_j\) 或 \(x_i\neq x_j\) 的變數相等/不等的約束條件，請判定是否可以分別為每一個變數賦予恰當的值，使得上述所有約束條件同時被滿足。例如，一個問題中的約束條件為：\(x_1=x_2,x_2=x_3,x_3=x_4,x_4\neq x_1\)，這些約束條件顯然是不可能同時被滿足的，因此這個問題應判定為不可被滿足。

現在給出一些約束滿足問題，請分別對它們進行判定。

輸入輸出格式

輸入格式

輸入的第一行包含一個正整數 \(t\)，表示需要判定的問題個數。注意這些問題之間是相互獨立的。

對於每個問題，包含若干行：

第一行包含一個正整數 \(n\)，表示該問題中需要被滿足的約束條件個數。接下來 \(n\) 行，每行包括三個整數 \(i,j,e\)，描述一個相等/不等的約束條件，相鄰整數之間用單個空格隔開。若 \(e=1\)，則該約束條件為 \(x_i=x_j\)。若\(e=0\)，則該約束條件為 \(x_i\neq x_j\)。

輸出格式

輸出包括 \(t\) 行。

輸出檔案的第 \(k\) 行輸出一個字串 YES

輸入輸出樣例

輸入樣例 #1

2
2
1 2 1
1 2 0
2
1 2 1
2 1 1

輸出樣例 #1

NO
YES

輸入樣例 #2

2
3
1 2 1
2 3 1
3 1 1
4
1 2 1
2 3 1
3 4 1
1 4 0

輸出樣例 #2

YES
NO

說明

【樣例解釋1】

在第一個問題中，約束條件為：\(x_1=x_2,x_1\neq x_2\)。這兩個約束條件互相矛盾，因此不可被同時滿足。

在第二個問題中，約束條件為：\(x_1=x_2,x_1 = x_2\)。這兩個約束條件是等價的，可以被同時滿足。

【樣例說明2】 在第一個問題中，約束條件有三個：\(x_1=x_2,x_2= x_3,x_3=x_1\)。只需賦值使得 \(x_1=x_2=x_3\)，即可同時滿足所有的約束條件。

在第二個問題中，約束條件有四個：\(x_1=x_2,x_2= x_3,x_3=x_4,x_4\neq x_1\)。由前三個約束條件可以推出 \(x_1=x_2=x_3=x_4\)，然而最後一個約束條件卻要求 \(x_1\neq x_4\)，因此不可被滿足。

【資料範圍】

注：實際上 \(n\le 10^6\) 。

分析

此題沒看資料範圍前，很容易就能想出是一道並查集。先將所有等號連線的兩個節點合併，再檢查所有的不等限制，如果不等號兩邊的節點在同一個集合，說明他們相等，和不等矛盾，輸出NO。如果所有都不矛盾，則輸出YES。

但是實際細節中我們還要注意資料範圍。\(1 \le i, j \le 1,000,000,000\)。這麼大的範圍開fa陣列程式直接MLE到炸。但是又能注意到 \(1 \le n \le 100,000\)，也就是說 \(n\) 的範圍不大，但是數字的範圍大。而在此題中我們只關心節點數字的大小關係，並不關心具體數值，自然想到用離散化將所有數字節點離散到 \(n\) 以內，再進行並查集演算法即可。

程式碼如下：

程式碼

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2020-08-19 18:52:22 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2020-08-20 01:57:10
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

const int maxn = 1000005;
int disc[maxn * 2], fa[maxn];

struct restrain {
    int i, j, e;
}a[maxn];

int find(int x) {
    while (x != fa[x]) x = fa[x] = fa[fa[x]];
    return x;
}

void unite(int x, int y) {
    fa[find(x)] = find(y);
    return ;
}

bool check(int x, int y) {
    return find(x) == find(y);
}

int main() {
    int t;
    std :: scanf("%d", &t);
    while (t--) {
        memset(a, 0, sizeof(a));
        memset(disc, 0, sizeof(disc));

        int n, discidx = 0;
        bool flag = true;
        std :: scanf("%d", &n);

        //離散化。disc是discretization(離散化)的縮寫。
        //disc陣列中，離散化資料從1開始儲存，disc[0]代表disc陣列一共有多少個離散化資料。
        for (int i = 1; i <= n; ++i) {
            std :: scanf("%d%d%d", &a[i].i, &a[i].j, &a[i].e);
            disc[++discidx] = a[i].i;
            disc[++discidx] = a[i].j;
        }

        std :: sort(disc + 1, disc + 1 + discidx);
        disc[0] = std :: unique(disc + 1, disc + 1 + discidx) - disc - 1;
        for (int i = 1; i <= n; ++i) {
            a[i].i = std :: lower_bound(disc + 1, disc + 1 + disc[0], a[i].i) - disc - 1 + 1;
            a[i].j = std :: lower_bound(disc + 1, disc + 1 + disc[0], a[i].j) - disc - 1 + 1;
        }

        //並查集開始
        for (int i = 1; i <= disc[0]; ++i)
            fa[i] = i;
        
        for (int i = 1; i <= n; ++i)
            if (a[i].e)
                unite(a[i].i, a[i].j);//先合併所有等號
        
        for (int i = 1; i <= n; ++i) {
            if (!a[i].e) {
                if (check(a[i].i, a[i].j)) {//同一集合，說明相等，與不等矛盾
                    std :: printf("NO\n");
                    flag = false;
                    break;
                }
            }
        }

        if (flag) std :: printf("YES\n");//所有都不矛盾
    }
}

評測記錄

評測記錄