UVa 1618 Weak Key

最新推荐文章于 2025-12-20 17:21:30 发布

原创最新推荐文章于 2025-12-20 17:21:30 发布 · 753 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

模拟专栏收录该内容

62 篇文章

订阅专栏

题目描述

哲洙是 $ICPC\texttt{ICPC}$ （国际密码程序公司）的密码学家。最近，他开发了一种名为 $ACM\texttt{ACM}$ （高级加密方法）的密码算法。 $ACM\texttt{ACM}$ 使用一个密钥来加密消息，加密后的消息称为密文。在 $ACM\texttt{ACM}$ 中，要解密密文需要使用与加密时相同的密钥。

英熙是 $ICPC\texttt{ICPC}$ 的密码分析师，她发现 $ACM\texttt{ACM}$ 算法存在弱密钥的问题。当使用弱密钥加密消息时，无需密钥就能轻易从密文中恢复消息。

$ACM\texttt{ACM}$ 使用一个互不相同的正整数序列 $(N1,N2,…,Nk)(N_1, N_2, \ldots, N_k)$ 作为密钥。弱密钥具有以下特殊模式：

在密钥中存在四个位置 $p < q < r < s$ ，使得满足以下两种模式之一：

$N_q > N_s > N_p > N_r$
$N_q < N_s < N_p < N_r$

例如，密钥 $(10, 30, 60, 40, 20, 50)$ 具有模式 $(1)$ ：取 $p = 1, q = 2, r = 4, s = 5$ ，则 $N_q=60 > N_s=50 > N_p=30 > N_r=20$ ，所以该密钥是弱密钥。

现在需要编写一个程序，对于给定的密钥序列，判断它是否为弱密钥。

输入格式

输入包含 $T$ 个测试用例。每个测试用例包含两行：

第一行：整数 $k$ $\leq k \leq 5000)$ ，表示密钥长度
第二行： $k$ 个互不相同的正整数 $\leq N_i \leq 100,000)$

输出格式

对于每个测试用例，输出一行：如果是弱密钥输出 $YES\texttt{YES}$ ，否则输出 $NO\texttt{NO}$ 。

题目分析

问题理解

我们需要在序列中寻找四个位置 $p < q < r < s$ ，满足以下两种不等式关系之一：

模式 1： $N_q > N_s > N_p > N_r$
模式 2： $N_q < N_s < N_p < N_r$

这两个模式可以理解为在序列中存在一个特定的"波浪形"或"锯齿形"关系。

暴力解法分析

最直接的解法是使用四重循环枚举所有可能的 $p, q, r, s$ 组合：

for (int p = 0; p < n; p++)
  for (int q = p+1; q < n; q++)
    for (int r = q+1; r < n; r++)
      for (int s = r+1; s < n; s++)
        if (检查模式1或模式2) return true;

这种方法的时间复杂度为 $O(k^4)$ ，对于 $k = 5000$ 来说完全不可行。

优化思路

我们可以重新组织搜索策略，将时间复杂度降低到 $O(k^3)$ ：

固定 $q$ 和 $s$ ：对于模式 1，我们固定 $q$ 和 $s$ ，其中 $q < s - 1$ （保证中间有位置给 $r$ ）
寻找 $p$ ：在 $q$ 的左边寻找满足 $N_p < N_s$ 的最大值作为候选 $p$
寻找 $r$ ：在 $q$ 和 $s$ 之间寻找满足 $N_r < N_p$ 的值

对于模式 2 采用类似的思路，但不等式关系相反。

算法步骤

模式 $1$ 检查 ( $N_q > N_s > N_p > N_r$ )

$1$ . 遍历所有可能的 $q$ $\leq q \leq k-3)$
$2$ . 对于每个 $q$ ，遍历所有可能的 $s$ $\leq s \leq k-1)$
$3$ . 如果 $N_q > N_s$ ：

在 $q$ 的左边找到小于 $N_s$ 的最大值作为候选 $p$
在 $q$ 和 $s$ 之间检查是否存在 $r$ 使得 $N_r < N_p$

模式 $2$ 检查 ( $N_q < N_s < N_p < N_r$ )

$1$ . 遍历所有可能的 $q$ $\leq q \leq k-3)$
$2$ . 对于每个 $q$ ，遍历所有可能的 $s$ $\leq s \leq k-1)$
$3$ . 如果 $N_q < N_s$ ：

在 $q$ 的左边找到大于 $N_s$ 的最小值作为候选 $p$
在 $q$ 和 $s$ 之间检查是否存在 $r$ 使得 $N_r > N_p$

复杂度分析

外层循环： $O (k)$
内层循环： $O (k)$
内部查找： $O (k)$
总复杂度： $O(k^3)$

虽然 $O(k^3)$ 在最坏情况下对于 $k = 5000$ 仍然较大，但由于实际数据可能不会达到最坏情况，且算法实现简单高效，这个解法在实际评测中能够通过。

解题代码

// Weak Key
// UVa ID: 1618
// Verdict: Accepted
// Submission Date: 2025-11-28
// UVa Run Time: 0.360s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const int INF = 1e9;

bool isWeakKey(const vector<int>& arr) {
    int n = arr.size();
    
    // 模式1: N_q > N_s > N_p > N_r
    for (int q = 1; q < n - 2; q++) {
        // 预处理：对于每个可能的s，快速判断是否存在满足条件的p和r
        int maxLeft = -INF;  // q左边最大值
        for (int p = 0; p < q; p++) {
            maxLeft = max(maxLeft, arr[p]);
        }
        
        // 对于每个s > q+1，如果arr[s] < arr[q]
        // 我们需要找到p使得arr[p] < arr[s]，且存在r在q和s之间使得arr[r] < arr[p]
        for (int s = q + 2; s < n; s++) {
            if (arr[s] < arr[q]) {
                // 在q左边找到小于arr[s]的最大值作为候选p
                int candidateP = -INF;
                for (int p = 0; p < q; p++) {
                    if (arr[p] < arr[s] && arr[p] > candidateP) {
                        candidateP = arr[p];
                    }
                }
                
                if (candidateP != -INF) {
                    // 检查q和s之间是否存在r使得arr[r] < candidateP
                    int minBetween = INF;
                    for (int r = q + 1; r < s; r++) {
                        minBetween = min(minBetween, arr[r]);
                    }
                    if (minBetween < candidateP) {
                        return true;
                    }
                }
            }
        }
    }
    
    // 模式2: N_q < N_s < N_p < N_r
    for (int q = 1; q < n - 2; q++) {
        int minLeft = INF;  // q左边最小值
        for (int p = 0; p < q; p++) {
            minLeft = min(minLeft, arr[p]);
        }
        
        for (int s = q + 2; s < n; s++) {
            if (arr[s] > arr[q]) {
                // 在q左边找到大于arr[s]的最小值作为候选p
                int candidateP = INF;
                for (int p = 0; p < q; p++) {
                    if (arr[p] > arr[s] && arr[p] < candidateP) {
                        candidateP = arr[p];
                    }
                }
                
                if (candidateP != INF) {
                    // 检查q和s之间是否存在r使得arr[r] > candidateP
                    int maxBetween = -INF;
                    for (int r = q + 1; r < s; r++) {
                        maxBetween = max(maxBetween, arr[r]);
                    }
                    if (maxBetween > candidateP) {
                        return true;
                    }
                }
            }
        }
    }
    
    return false;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int testCases;
    cin >> testCases;
    
    while (testCases--) {
        int k;
        cin >> k;
        vector<int> key(k);
        for (int i = 0; i < k; i++) cin >> key[i];
        
        if (isWeakKey(key)) cout << "YES\n";
        else cout << "NO\n";
    }
    
    return 0;
}

另外一种实现：

// Weak Key
// UVa ID: 1618
// Verdict: Accepted
// Submission Date: 2025-11-28
// UVa Run Time: 0.240s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const int INF = 1e9;

bool isWeakKey(const vector<int>& arr) {
    int n = arr.size();
    
    // 预处理每个区间的最小值和最大值
    vector<vector<int>> minInRange(n, vector<int>(n, INF));
    vector<vector<int>> maxInRange(n, vector<int>(n, -INF));
    
    for (int i = 0; i < n; i++) {
        minInRange[i][i] = maxInRange[i][i] = arr[i];
        for (int j = i + 1; j < n; j++) {
            minInRange[i][j] = min(minInRange[i][j - 1], arr[j]);
            maxInRange[i][j] = max(maxInRange[i][j - 1], arr[j]);
        }
    }
    
    // 预处理每个位置左边的有序数组
    vector<multiset<int>> leftSets(n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            leftSets[i].insert(arr[j]);
        }
    }
    
    // 检查两种模式
    for (int q = 1; q < n - 2; q++) {
        for (int s = q + 2; s < n; s++) {
            // 模式1: N_q > N_s > N_p > N_r
            if (arr[q] > arr[s]) {
                auto it = leftSets[q].lower_bound(arr[s]);
                if (it != leftSets[q].begin()) {
                    it--;
                    int candidateP = *it;
                    if (minInRange[q + 1][s - 1] < candidateP) {
                        return true;
                    }
                }
            }
            // 模式2: N_q < N_s < N_p < N_r
            else if (arr[q] < arr[s]) {
                auto it = leftSets[q].upper_bound(arr[s]);
                if (it != leftSets[q].end()) {
                    int candidateP = *it;
                    if (maxInRange[q + 1][s - 1] > candidateP) {
                        return true;
                    }
                }
            }
        }
    }
    
    return false;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int testCases;
    cin >> testCases;
    
    while (testCases--) {
        int k;
        cin >> k;
        vector<int> key(k);
        for (int i = 0; i < k; i++) cin >> key[i];
        
        cout << (isWeakKey(key) ? "YES" : "NO") << endl;
    }
    
    return 0;
}