2021财院ACM选拔赛题解

最新推荐文章于 2022-09-27 21:32:00 发布
最新推荐文章于 2022-09-27 21:32:00 发布
阅读量445 收藏 3
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pitaohc/article/details/115282251
版权

本题解只是参考答案，思路并不唯一！！！

A题 存款利息

方法一

本题主要考察循环语句，题目较为简单，直接看代码

C语言


#include <stdio.h>
int main()
{
	double money_1,money_2;
	scanf("%lf", &money_1);
	money_2 = money_1;
	money_1 += money_1 * 4 * 0.0275; //存四年，复利计息
	for (int i = 0; i < 4; ++i)
	{
		money_2 += money_2 * 0.0175; //加上一年的利息，单利计息
	}
	printf("%.2lf %.2lf", money_1,money_2);
	return 0;
}

B题 判断闰年

方法一

本题主要考察if判断，要掌握闰年的条件。
闰年条件：

  1. 能被4整除但不能被100整除
  2. 能被400整除

C语言

#include <stdio.h>
int main()
{
	int year, mon, day;
	scanf("%d-%d-%d", &year, &mon, &day);
	if(year % 400 == 0 || year % 4 == 0 && year % 100 != 0) //闰年条件
	{
		printf("%s", "yes");
	}
	else
	{
		printf("%s", "no");
	}
	return 0;
}

C题 acb模式

题目来源：132-pattern

前言

由于本题中 n n n 的最大值可以到 1 0 4 10^4 104
，因此对于一个满足 a c b acb acb 模式的三元组下标 ( i , j , k ) (i, j, k) (i,j,k)，枚举其中的 2 个下标时间复杂度为 O ( n 2 ) O(n^2) O(n2)
，很容易超出时间限制。

因此我们可以考虑枚举其中的 1 1 1 个下标，并使用合适的数据结构维护另外的 2 2 2 个下标的可能值。

方法一 枚举 c

枚举 c c c 是容易想到并且也是最容易实现的。由于 c c c 是模式中的最大值，并且其出现在 a a a 和 b b b 的中间，因此我们只需要从左到右枚举 c c c 的下标 j j j，那么：

由于 a a a 是模式中的最小值，因此我们在枚举 j j j 的同时，维护数组 a 中左侧元素 a [ 0.. j − 1 ] a[0..j-1] a[0..j−1] 的最小值，即为 a a a 对应的元素 a [ i ] a[i] a[i]。需要注意的是，只有 a [ i ] < a [ j ] a[i] < a[j] a[i]<a[j] 时， a [ i ] a[i] a[i] 才能作为 a 对应的元素；

由于 b b b 是模式中的次小值，因此我们可以使用一个有序集合（例如平衡树）维护数组 a a a 中右侧元素 a [ j + 1.. n − 1 ] a[j+1..n-1] a[j+1..n−1] 中的所有值。当我们确定了 a [ i ] a[i] a[i] 和 a [ j ] a[j] a[j] 之后，只需要在有序集合中查询严格比 a [ i ] a[i] a[i] 大的那个最小的元素，即为 a [ k ] a[k] a[k]。需要注意的是，只有 $a[k] < a[j] 时 ， 时， 时，a[k]$ 才能作为 c c c 对应的元素。

C++

#include<iostream>
#include <set>
#include <vector>
using namespace std;
class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        int n = nums.size();
        if (n < 3) {
            return false;
        }
        // 左侧最小值
        int left_min = nums[0];
        // 右侧所有元素
        multiset<int> right_all;
        for (int k = 2; k < n; ++k) {
            right_all.insert(nums[k]);
        }
        for (int j = 1; j < n - 1; ++j) {
            if (left_min < nums[j]) {
                auto it = right_all.upper_bound(left_min);
                if (it != right_all.end() && *it < nums[j]) {
                    return true;
                }
            }
            left_min = min(left_min, nums[j]);
            right_all.erase(right_all.find(nums[j + 1]));
        }
        return false;
    }
};
int main()
{
    Solution sol;
    int n;
    cin >> n;
    vector<int> array(n);
    for (int i = 0; i < n; ++i){
        cin >> array[i];
    }
    bool res = sol.find132pattern(array);
	if(res){
        cout << "True";
	}
    else{
        cout << "False";
    }
    return 0;
}

Java

import java.io.*;
import java.util.*;
import java.util.TreeMap;
class Solution {
    public boolean find132pattern(int[] nums) {
        // a < c < b
        int n = nums.length;
        if (n < 3) return false;
        TreeMap<Integer, Integer> rightNums = new TreeMap<>();//储存当前位置右边的 <数值,个数> c
        int leftMin = nums[0]; // 左侧最小值 a
        for (int i = 2; i < n; i++) {
            rightNums.put(nums[i], rightNums.getOrDefault(nums[i], 0) + 1);
        }
        for (int i = 1; i < n - 1; i++) {
            //检查
            if (leftMin < nums[i]) { // a<b
                Integer c = rightNums.ceilingKey(leftMin + 1); //获得比a大的最小元素 c>=a+1
                if (c != null && c < nums[i]) { //c<b
                    return true; //符合情况
                }
            }
            //维护结构
            rightNums.put(nums[i + 1], rightNums.get(nums[i + 1]) - 1);
            if (rightNums.get(nums[i + 1]) == 0) rightNums.remove(nums[i + 1]);
            leftMin = Math.min(leftMin, nums[i]);
        }
        return false;
    }
}
public class Main {
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();
        int[] arr = new int[n];
        for(int i =0;i<n;++i){
            arr[i]=cin.nextInt();
        }
        Solution sol = new Solution();
        if(sol.find132pattern(arr)){
            System.out.print("True");
        }else{
            System.out.print("False");
        }
    }
}

方法二 枚举a

如果我们从左到右枚举 a a a 的下标 i i i，那么 j , k j, k j,k 的下标范围都是减少的，这样就不利于对它们进行维护。因此我们可以考虑从右到左枚举 i i i。

那么我们应该如何维护 j , k j, k j,k 呢？在 a c b acb acb 模式中，如果 a < b a<b a<b 并且 b < c b<c b<c，那么根据传递性， a < c a<c a<c 也是成立的，那么我们可以使用下面的方法进行维护：

  • 我们使用一种数据结构维护所有遍历过的元素，它们作为 b b b 的候选元素。每当我们遍历到一个新的元素时，就将其加入数据结构中；

  • 在遍历到一个新的元素的同时，我们可以考虑其是否可以作为 c c c。如果它作为 c c c，那么数据结构中所有严格小于它的元素都可以作为 b b b，我们将这些元素全部从数据结构中移除，并且使用一个变量维护所有被移除的元素的最大值。这些被移除的元素都是可以真正作为 b b b 的，并且元素的值越大，那么我们之后找到 a a a 的机会也就越大。

那么这个「数据结构」是什么样的数据结构呢？我们尝试提取出它进行的操作：

  • 它需要支持添加一个元素；

  • 它需要支持移除所有严格小于给定阈值的所有元素；

  • 上面两步操作是「依次进行」的，即我们先用给定的阈值移除元素，再将该阈值加入数据结构中。

这就是「单调栈」。在单调栈中，从栈底到栈顶的元素是严格单调递减的。当给定阈值 x x x 时，我们只需要不断地弹出栈顶的元素，直到栈为空或者 x x x 严格小于栈顶元素。此时我们再将 x x x 入栈，这样就维护了栈的单调性。

因此，我们可以使用单调栈作为维护 b b b 的数据结构，并给出下面的算法：

  • 我们用单调栈维护所有可以作为 b b b 的候选元素。初始时，单调栈中只有唯一的元素 a [ n − 1 ] \textit{a}[n-1] a[n−1]。我们还需要使用一个变量 max_k \textit{max\_k} max_k 记录所有可以真正作为 b b b 的元素的最大值；

  • 随后我们从 n − 2 n-2 n−2 开始从右到左枚举元素 a [ i ] a[i] a[i]：

    • 首先我们判断 a [ i ] a[i] a[i] 是否可以作为 a a a。如果 a [ i ] < max_k a[i] < \textit{max\_k} a[i]<max_k，那么它就可以作为 a a a，我们就找到了一组满足 a c b acb acb 模式的三元组；

    • 随后我们判断 a [ i ] a[i] a[i] 是否可以作为 c c c，以此找出哪些可以真正作为 b b b 的元素。我们将 a [ i ] a[i] a[i] 不断地与单调栈栈顶的元素进行比较，如果 a [ i ] a[i] a[i] 较大，那么栈顶元素可以真正作为 b b b，将其弹出并更新 max_k \textit{max\_k} max_k；

    • 最后我们将 a [ i ] a[i] a[i] 作为 b b b 的候选元素放入单调栈中。这里可以进行一个优化，即如果 a [ i ] ≤ max_k a[i] \leq \textit{max\_k} a[i]≤max_k，那么我们也没有必要将 a [ i ] a[i] a[i] 放入栈中，因为即使它在未来被弹出，也不会将 max_k \textit{max\_k} max_k 更新为更大的值。

  • 在枚举完所有的元素后，如果仍未找到满足 acb 模式的三元组，那就说明其不存在。

C语言

#include<stdio.h>
#define bool int
#define false 0
#define true 1
bool find132pattern(int* nums, int numsSize) {
    int n = numsSize;
    int candidate_k[n], top = 0;
    candidate_k[top++] = nums[n - 1];
    int max_k = INT_MIN;

    for (int i = n - 2; i >= 0; --i) {
        if (nums[i] < max_k) {
            return true;
        }
        while (top && nums[i] > candidate_k[top - 1]) {
            max_k = candidate_k[--top];
        }
        if (nums[i] > max_k) {
            candidate_k[top++] = nums[i];
        }
    }

    return false;
}
int main()
{
	int n;
	scanf("%d",&n);
	int array[10000000];
	for(int i=0; i<n; ++i){
		scanf("%d",array+i);
	}
	bool ans = find132pattern(array,n);
	if(ans) printf("True");
	else printf("False");
	return 0;
}

C++

#include<vector>
#include<iostream>
class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        int n = nums.size();
        stack<int> candidate_k;
        candidate_k.push(nums[n - 1]);
        int max_k = INT_MIN;

        for (int i = n - 2; i >= 0; --i) {
            if (nums[i] < max_k) {
                return true;
            }
            while (!candidate_k.empty() && nums[i] > candidate_k.top()) {
                max_k = candidate_k.top();
                candidate_k.pop();
            }
            if (nums[i] > max_k) {
                candidate_k.push(nums[i]);
            }
        }
        return false;
    }
};
int main()
{
    Solution sol;
    int n;
    cin >> n;
    vector<int> array(n);
    for (int i = 0; i < n; ++i){
        cin >> array[i];
    }
    bool res = sol.find132pattern(array);
	if(res){
        cout << "True";
	}
    else{
        cout << "False";
    }
    return 0;
}

Java

import java.io.*;
import java.util.*;
import java.util.TreeMap;
class Solution {
    public boolean find132pattern(int[] nums) {
        int n = nums.length;
        Deque<Integer> candidateK = new LinkedList<Integer>();
        candidateK.push(nums[n - 1]);
        int maxK = Integer.MIN_VALUE;

        for (int i = n - 2; i >= 0; --i) {
            if (nums[i] < maxK) {
                return true;
            }
            while (!candidateK.isEmpty() && nums[i] > candidateK.peek()) {
                maxK = candidateK.pop();
            }
            if (nums[i] > maxK) {
                candidateK.push(nums[i]);
            }
        }

        return false;
    }
}
public class Main {
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();
        int[] arr = new int[n];
        for(int i =0;i<n;++i){
            arr[i]=cin.nextInt();
        }
        Solution sol = new Solution();
        if(sol.find132pattern(arr)){
            System.out.print("True");
        }else{
            System.out.print("False");
        }
    }
}

D题 方形星系

题目来源：spiral-matrix-ii

方法一：模拟

模拟矩阵的生成。按照要求，初始位置设为矩阵的左上角，初始方向设为向右。若下一步的位置超出矩阵边界，或者是之前访问过的位置，则顺时针旋转，进入下一个方向。如此反复直至填入 n 2 n^2 n2
个元素。

记 matrix \textit{matrix} matrix 为生成的矩阵，其初始元素设为 0 0 0。由于填入的元素均为正数，我们可以判断当前位置的元素值，若不为 0 0 0，则说明已经访问过此位置。

C语言

#include<stdio.h>
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes) {
    int maxNum = n * n;
    int curNum = 1;
    int** matrix = malloc(sizeof(int*) * n);
    *returnSize = n;
    *returnColumnSizes = malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        matrix[i] = malloc(sizeof(int) * n);
        memset(matrix[i], 0, sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }
    int row = 0, column = 0;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};  // 右下左上
    int directionIndex = 0;
    while (curNum <= maxNum) {
        matrix[row][column] = curNum;
        curNum++;
        int nextRow = row + directions[directionIndex][0], nextColumn = column + directions[directionIndex][1];
        if (nextRow < 0 || nextRow >= n || nextColumn < 0 || nextColumn >= n || matrix[nextRow][nextColumn] != 0) {
            directionIndex = (directionIndex + 1) % 4;  // 顺时针旋转至下一个方向
        }
        row = row + directions[directionIndex][0];
        column = column + directions[directionIndex][1];
    }
    return matrix;
}
int main(){
	int n;
	scanf("%d",&n);
	int size,columnSizes;
	int** matrix = generateMatrix(m,&size,&columnSizes);
	for(int i=0;i<size;++i){
		for(int j=0;j<columnSizes;++j){
			if(j>0) printf(" ");
			printf("%d",matrix[i][j]);
		}
		printf("\n");
	}
	return 0;
}

C++

#include<vector>
#include<iostream>
using namespace std;
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int maxNum = n * n;
        int curNum = 1;
        vector<vector<int>> matrix(n, vector<int>(n));
        int row = 0, column = 0;
        vector<vector<int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};  // 右下左上
        int directionIndex = 0;
        while (curNum <= maxNum) {
            matrix[row][column] = curNum;
            curNum++;
            int nextRow = row + directions[directionIndex][0], nextColumn = column + directions[directionIndex][1];
            if (nextRow < 0 || nextRow >= n || nextColumn < 0 || nextColumn >= n || matrix[nextRow][nextColumn] != 0) {
                directionIndex = (directionIndex + 1) % 4;  // 顺时针旋转至下一个方向
            }
            row = row + directions[directionIndex][0];
            column = column + directions[directionIndex][1];
        }
        return matrix;
    }
};
int main()
{
	int n;
	cin>>n;
	Solution sol;
	vector<vector<int>> matrix = sol.generateMatrix(n);
	for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
                if(j>0) cout<<" ";
                cout<<matrix[i][j];
            }
            cout<<endl;
    }
	return 0;
}

Java

import java.util.Scanner;
class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        int index = 1;
        int row = 0, col = 0;
        final int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int directionIndex = 0;

        while (index <= n * n) {
            matrix[row][col] = index;
            int newRow = row + directions[directionIndex][0];
            int newCol = col + directions[directionIndex][1];
            if (newRow < 0 || newRow >= n || newCol < 0 || newCol >= n || matrix[newRow][newCol] != 0) {
                ++directionIndex;
                directionIndex %= 4;
            }
            row += directions[directionIndex][0];
            col += directions[directionIndex][1];
            ++index;
        }
        return matrix;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Solution solution = new Solution();
        int n = in.nextInt();
        int[][] matrix = solution.generateMatrix(n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(j>0) System.out.print(" ");
                System.out.print(matrix[i][j]);
            }
            System.out.print("\n");
        }
    }
}

方法二：按层模拟

可以将矩阵看成若干层，首先填入矩阵最外层的元素，其次填入矩阵次外层的元素，直到填入矩阵最内层的元素。

定义矩阵的第 kk 层是到最近边界距离为 kk 的所有顶点。例如，下图矩阵最外层元素都是第 11 层，次外层元素都是第 22 层，最内层元素都是第 33 层。

[[1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 2, 1],
[1, 2, 3, 3, 2, 1],
[1, 2, 3, 3, 2, 1],
[1, 2, 2, 2, 2, 1],
[1, 1, 1, 1, 1, 1]]
对于每层，从左上方开始以顺时针的顺序填入所有元素。假设当前层的左上角位于 ( top , left ) (\textit{top}, \textit{left}) (top,left)，右下角位于 ( bottom , right ) (\textit{bottom}, \textit{right}) (bottom,right)，按照如下顺序填入当前层的元素。

从左到右填入上侧元素，依次为 ( top , left ) (\textit{top}, \textit{left}) (top,left) 到 ( top , right ) (\textit{top}, \textit{right}) (top,right)。

从上到下填入右侧元素，依次为 ( top + 1 , right ) (\textit{top} + 1, \textit{right}) (top+1,right) 到 ( bottom , right ) (\textit{bottom}, \textit{right}) (bottom,right)。

如果 left < right \textit{left} < \textit{right} left<right 且 top < bottom \textit{top} < \textit{bottom} top<bottom，则从右到左填入下侧元素，依次为 ( bottom , right − 1 ) (\textit{bottom}, \textit{right} - 1) (bottom,right−1) 到 ( bottom , left + 1 ) (\textit{bottom}, \textit{left} + 1) (bottom,left+1)，以及从下到上填入左侧元素，依次为 ( bottom , left ) (\textit{bottom}, \textit{left}) (bottom,left) 到 ( top + 1 , left ) (\textit{top} + 1, \textit{left}) (top+1,left)。

填完当前层的元素之后，将 left \textit{left} left 和 top \textit{top} top 分别增加 1 1 1，将 right \textit{right} right 和 bottom \textit{bottom} bottom 分别减少 1 1 1，进入下一层继续填入元素，直到填完所有元素为止。

C语言

#include<stdio.h>
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes) {
    int num = 1;
    int** matrix = malloc(sizeof(int*) * n);
    *returnSize = n;
    *returnColumnSizes = malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        matrix[i] = malloc(sizeof(int) * n);
        memset(matrix[i], 0, sizeof(int) * n);
        (*returnColumnSizes)[i] = n;
    }
    int left = 0, right = n - 1, top = 0, bottom = n - 1;
    while (left <= right && top <= bottom) {
        for (int column = left; column <= right; column++) {
            matrix[top][column] = num;
            num++;
        }
        for (int row = top + 1; row <= bottom; row++) {
            matrix[row][right] = num;
            num++;
        }
        if (left < right && top < bottom) {
            for (int column = right - 1; column > left; column--) {
                matrix[bottom][column] = num;
                num++;
            }
            for (int row = bottom; row > top; row--) {
                matrix[row][left] = num;
                num++;
            }
        }
        left++;
        right--;
        top++;
        bottom--;
    }
    return matrix;
}
int main(){
	int n;
	scanf("%d",&n);
	int size,columnSizes;
	int** matrix = generateMatrix(m,&size,&columnSizes);
	for(int i=0;i<size;++i){
		for(int j=0;j<columnSizes;++j){
			if(j>0) printf(" ");
			printf("%d",matrix[i][j]);
		}
		printf("\n");
	}
	return 0;
}

C++

#include<vector>
#include<iostream>
using namespace std;
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int num = 1;
        vector<vector<int>> matrix(n, vector<int>(n));
        int left = 0, right = n - 1, top = 0, bottom = n - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                matrix[top][column] = num;
                num++;
            }
            for (int row = top + 1; row <= bottom; row++) {
                matrix[row][right] = num;
                num++;
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    matrix[bottom][column] = num;
                    num++;
                }
                for (int row = bottom; row > top; row--) {
                    matrix[row][left] = num;
                    num++;
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return matrix;
    }
};
int main()
{
	int n;
	cin>>n;
	Solution sol;
	vector<vector<int>> matrix = sol.generateMatrix(n);
	for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
                if(j>0) cout<<" ";
                cout<<matrix[i][j];
            }
            cout<<endl;
    }
	return 0;
}

Java

import java.util.Scanner;
class Solution {
    public int[][] generateMatrix(int n) {
        int num = 1;
        int[][] matrix = new int[n][n];
        int left = 0, right = n - 1, top = 0, bottom = n - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                matrix[top][column] = num;
                num++;
            }
            for (int row = top + 1; row <= bottom; row++) {
                matrix[row][right] = num;
                num++;
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    matrix[bottom][column] = num;
                    num++;
                }
                for (int row = bottom; row > top; row--) {
                    matrix[row][left] = num;
                    num++;
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return matrix;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Solution solution = new Solution();
        int n = in.nextInt();
        int[][] matrix = solution.generateMatrix(n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(j>0) System.out.print(" ");
                System.out.print(matrix[i][j]);
            }
            System.out.print("\n");
        }
    }
}

E题 乾坤挪移

方法一 假装移动数组

每次输出数组时，都从第 i i i 位输出，需要输出 n n n 个元素，可以利用取模运算符获得正确的下标

C语言

#include <stdio.h>
#include <malloc.h>
int main()
{
	int n;
	scanf("%d", &n);
	int* array = (int*)malloc(sizeof(int) * n); //动态创建一个n个元素的数组
	for (int i = 0; i < n; ++i)
	{
		scanf("%d", array + i);
	}
	for (int i = 0; i < n; ++i)
	{
		for (int j = i; j < i+n; ++j)
		{
			if (j > i) printf(" ");
			printf("%d", array[j % n]);
		}
		printf("\n");
	}
	free(array); //释放array
	array = NULL;
	return 0;
}

C++

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	int n;
	cin >> n;
	vector<int> array(n);
	for (int i = 0; i < n; ++i)
	{
		cin >> array[i];
	}
	for (int i = 0; i < n; ++i)
	{
		for (int j = i; j < i+n; ++j)
		{
			if (j > i) cout << " ";
			cout << array[j % n];
		}
		cout << endl;
	}
	return 0;
}

Java

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n;
        n = in.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = in.nextInt();
        }
        for (int i = 0; i < n; i++) {
            for (int j = i; j < i + n; j++) {
                if (j > i) System.out.print(" ");
                System.out.print(array[j % n]);
            }
            System.out.print("\n");
        }
    }
}

F题 下一个更小元素

题目来源：next-greater-element-ii

方法一：单调栈 + 循环数组

我们可以使用单调栈解决本题。单调栈中保存的是下标，从栈底到栈顶的下标在数组 nums \textit{nums} nums 中对应的值是单调不升的。

每次我们移动到数组中的一个新的位置 i i i，我们就将当前单调栈中所有对应值小于 nums [ i ] \textit{nums}[i] nums[i] 的下标弹出单调栈，这些值的下一个更大元素即为 nums [ i ] \textit{nums}[i] nums[i]（证明很简单：如果有更靠前的更大元素，那么这些位置将被提前弹出栈）。随后我们将位置 i i i 入栈。

但是注意到只遍历一次序列是不够的，例如序列 [ 2 , 3 , 1 ] [2,3,1] [2,3,1]，最后单调栈中将剩余 [ 3 , 1 ] [3,1] [3,1]，其中元素 [ 1 ] [1] [1] 的下一个更大元素还是不知道的。

一个朴素的思想是，我们可以把这个循环数组「拉直」，即复制该序列的前 n − 1 n-1 n−1 个元素拼接在原序列的后面。这样我们就可以将这个新序列当作普通序列，用上文的方法来处理。

而在本题中，我们不需要显性地将该循环数组「拉直」，而只需要在处理时对下标取模即可。

C语言

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int* nextGreaterElements(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    if (numsSize == 0) {
        return NULL;
    }
    int* ret = malloc(sizeof(int) * numsSize);
    memset(ret, -1, sizeof(int) * numsSize);

    int stk[numsSize * 2 - 1], top = 0;
    for (int i = 0; i < numsSize * 2 - 1; i++) {
        while (top > 0 && nums[stk[top - 1]] > nums[i % numsSize]) {
            ret[stk[top - 1]] = nums[i % numsSize];
            top--;
        }
        stk[top++] = i % numsSize;
    }
    return ret;
}
int main()
{
    int n;
    scanf("%d", &n);
    int* array = malloc(sizeof(int) * n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", array+i);
    }
    int len;
    int* ans = nextGreaterElements(array, n, &len);

    for (int i = 0; i < n; ++i)
    {
        if (i > 0) printf(" ");
        printf("%d", ans[i]);
    }
    return 0;
}

C++

#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> ret(n, -1);
        stack<int> stk;
        for (int i = 0; i < n * 2 - 1; i++) {
            while (!stk.empty() && nums[stk.top()] > nums[i % n]) {
                ret[stk.top()] = nums[i % n];
                stk.pop();
            }
            stk.push(i % n);
        }
        return ret;
    }
};
int main()
{
    int n;
    cin >> n;
    Solution sol;
    vector<int> array(n);
    for (int i = 0; i < n; ++i)
    {
        cin >> array[i];
    }
    auto ans = sol.nextGreaterElements(array);
    for (int i = 0; i < ans.size(); ++i)
    {
        if (i > 0) cout << " ";
        cout << ans[i];
    }

    return 0;
}

Java

import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int[] ret = new int[n];
        Arrays.fill(ret, -1);
        Deque<Integer> stack = new LinkedList<Integer>();
        for (int i = 0; i < n * 2 - 1; i++) {
            while (!stack.isEmpty() && nums[stack.peek()] > nums[i % n]) {
                ret[stack.pop()] = nums[i % n];
            }
            stack.push(i % n);
        }
        return ret;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = in.nextInt();
        }
        Solution sol = new Solution();
        int[] ans = sol.nextGreaterElements(array);
        for (int i = 0; i < n; i++) {
            if (i > 0) System.out.print(" ");
            System.out.print(array[i]);
        }
    }
}

G题 求解高次方程

方法一：二分查找

通过求导可得该函数在 [ 20 , 50 ] [20,50] [20,50] 上是单调递增函数，则设 f ( x 0 ) = 0 f(x_0)=0 f(x0​)=0，有 x < x 0 , f ( x ) < f ( x 0 ) x<x_0, f(x)<f(x_0) x<x0​,f(x)<f(x0​)或 x > x 0 , f ( x ) > f ( x 0 ) x>x_0, f(x)>f(x_0) x>x0​,f(x)>f(x0​)，函数图像如图
函数图像
可得在这一区间内，函数值是从小到大有序的，可以使用二分查找找到特定值

C

#include <stdio.h>
#include <math.h>

inline double f(const double x)
{
	// f(x)=x^4+70*x^3-4175*x^2+15750*x-275625;

	return pow(x, 4) + 70 * pow(x, 3) - 4175 * pow(x, 2) + 15750 * x - 275625;
}
double binarySearch(double left, double right)
{
	int i = 1;
	const double delta = 0.000000000001;
	double mid;
	while (left < right)
	{
		mid = (left + right) / 2;
		double val = f(mid);
		//cout <<i <<" "<< "f(" << mid << ")= " << val << endl;
		if (-delta <= val && val <= delta)
		{
			return mid;
		}
		else if (val < -delta)
		{
			left = mid + delta;
		}
		else
		{
			right = mid - delta;
		}
		++i;
	}
	return mid;
}

int main()
{
	double ans = binarySearch(20.0, 50.0);
	printf("%.6lf", ans);
	return 0;
}

C++

#include <iostream>
#include <math.h>
#include <iomanip>
using namespace std;
inline double f(double x){
	// f(x)=x^4+70*x^3-4175*x^2+15750*x-275625;
	return pow(x, 4) + 70 * pow(x, 3) - 4175 * pow(x, 2) + 15750 * x - 275625;
}
double binarySearch(double left, double right){
	int i = 1;
	double delta = 0.000000000001;
	double mid;
	while (left<right){
		mid = (left + right) / 2;
		double val = f(mid);
		//cout <<i <<" "<< "f(" << mid << ")= " << val << endl;
		if(-delta <= val && val <= delta){
			return mid;
		}
		else if(val<-delta){
			left = mid + delta;
		}
		else{
			right = mid - delta;
		}
		++i;
	}
	return mid;
}
int main(){
	double ans = binarySearch(20.0, 50.0);
	//格式控制 fixed 小数表示，setprecision(n)保留n位小数
	cout << setiosflags(ios::fixed) << setprecision(6) << ans;
	return 0;
}

H题 存在重复元素

题目来源：contains-duplicate

方法一：排序

在对数字从小到大排序之后，数组的重复元素一定出现在相邻位置中。因此，我们可以扫描已排序的数组，每次判断相邻的两个元素是否相等，如果相等则说明存在重复的元素。
但是时间复杂度为 n log ⁡ ( n ) n\log(n) nlog(n)，会超时。

C

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define scanf scanf_s
int cmp(const void* _a, const void* _b) {
    int a = *(int*)_a, b = *(int*)_b;
    return a - b;
}
bool containsDuplicate(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), cmp);
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            return true;
        }
    }
    return false;
}
int main()
{
    int n;
    scanf("%d", &n);
    int* array = malloc(sizeof(int) * n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", array + i);
    }
    if (containsDuplicate(array, n))
        printf("true");
    else
        printf("false");
    free(array);
    return 0;
}

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
};
int main()
{
	int n;
	cin >> n;
	vector<int> array(n);
	for (int i = 0; i < n; ++i)
	{
		cin >> array[i];
	}
    Solution sol;
    if (sol.containsDuplicate(array)) cout << "true";
    else cout << "false";
	return 0;
}

Java

import java.util.Arrays;
import java.util.Scanner;

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = in.nextInt();
        }
        Solution sol = new Solution();
        if(sol.containsDuplicate(array)) System.out.print("true");
        else System.out.print("false");

    }
}

方法二：哈希表

对于数组中每个元素，我们将它插入到哈希表中。如果插入一个元素时发现该元素已经存在于哈希表中，则说明存在重复的元素。

C++

#include<iostream>
#include<vector>
#include<set>
#include<unordered_set>
using namespace std;
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        //使用stl的set
        unordered_set<int> hash;
        for (auto& elem : nums){
            auto res = hash.insert(elem);
            if (!res.second) return true;
        }
        return false;
    }
};

int main() {
    int n;
    cin >> n;
    vector<int> vect(n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", &vect[i]);
        //cin >> vect[i];
    }
    Solution sol;
    if (sol.containsDuplicate(vect)) {
        cout << "true";
    }
    else {
        cout << "false";
    }
    return 0;
}

Java

import java.util.*;
class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int x : nums) {
            if (!set.add(x)) {
                return true;
            }
        }
        return false;
    }
}
public class Main{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[] array = new int[n];
		for(int i=0;i<n;++i){
			array[i]=in.nextInt();
		}
		Solution sol = new Solution();
        if(sol.containsDuplicate(array)) System.out.print("true");
        else System.out.print("false");
	}
}
pitaohc
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
第十一届山东省大学生程序设计竞赛题解（9 / 13）
繁凡さん的博客
05-18 2502
体验不是太好，后面的题都不是很想补 B 边权为 gcd⁡(ai,aj)\gcd(a_i, a_j)gcd(ai​,aj​)，显然如果存在一个点 axa_xax​ 是素数，则从该点向所有的点连边，这样连接的 n−1n-1n−1条边的权值都是1，答案就是 n−1n-1n−1 。 若 L=RL=RL=R，则 R+L+1=1R+L+1=1R+L+1=1，模1之后得到的显然都是0，也就是说 n2n^2n2 条边的权值都是 LLL，答案显然就是 L×(n−1)L\times (n-1)L×(n−1)。 然后因为 nn
财经学院网站管理办法.docx
12-19
财经学院网站管理办法.docx
2021浙江省ACM省赛后记
StandNotAlone的博客
04-20 4080
省赛是17号周六打的，打完省赛后准备布置18号的蓝桥杯，补了一波windows啊j2ee啊数据库啊一堆作业，顺便趁着打折在steam上买了一波卡婊的游戏，总算是可以安静坐下来写一下省赛的后记啦。 今年的省赛从线上改成了线下(又是线下…杭师范没去成)。 还是和往常一样，我很早就把需要准备的东西都从一楼实验室搬到了三楼比赛场地，确认了一下各种可能用到漏带上来的东西，然后就是安静得等HL和GBS学长来啦。 我们队伍的配置呢，是我一个只会勉强熟练使用基础算法的思维型大二队员，和两位曾经在区域赛省赛都夺过金的大四学长
2021-2022-1 ACM集训队每周程序设计竞赛（3）题解
yueshehanjiang的博客
10-06 1484
A - 苹果派 题意： 你有a个苹果和p个苹果片你有a个苹果和p个苹果片你有a个苹果和p个苹果片 1个苹果可以制作3个苹果片1个苹果可以制作3个苹果片1个苹果可以制作3个苹果片 2个苹果片可以制作1个苹果派2个苹果片可以制作1个苹果派2个苹果片可以制作1个苹果派 问一共可以制作多少个苹果派问一共可以制作多少个苹果派问一共可以制作多少个苹果派 0<=a,p<=1000 <= a , p <= 1000<=a,p<=100 思路： 模拟模拟模拟 时间复杂度：O1O1O1 #i
数组-螺旋矩阵ⅠⅡⅢ-中等-20210907
qq_40008772的博客
09-10 159
54螺旋矩阵 1. 题目描述 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。 示例： [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5] [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,
ICPC2021山东省赛总结
ojzha的博客
05-14 1121
按时间线走… 首先是TG 很签到，看到数据范围就知道只能模拟除法。 然后我和栋哥开TD去了 题意就是薛定谔的箱子(bushi)，一个箱子没开之前不知道里面的重力场方向，有可能是水平向左，也可能是竖直向下，这个箱子里面有一些小方块，求每次打开箱子后再两种重力作用下形成的轮廓的周长。 idea：两种情况是一样的 在峰哥狂过了B C J题之后，发现还剩下M题是可做的，然后开始了与M题的拉锯战… 首先栋哥贡献了14发WA，最后半小时我开始打M，打到最后5min才终于过掉，前前后后一共WA了20发啊啊啊啊啊qwq
【Java/补题/牛客/ACM赛制】2021年ICPC国际大学生程序设计竞赛暨陕西省第九届大学生程序设计竞赛（正式赛）
m0_51226527的博客
09-27 1083
C - GCD（数论分块）
广西财经学院惠普云平台技术方案.doc
03-08
广西财经学院惠普云平台技术方案旨在为学院提供高效、灵活且可扩展的计算资源，以支持教育信息化的发展。此方案详细阐述了学院对云计算资源平台的需求，以及惠普（HP）提出的解决方案。 1. 需求分析： 在当前数字化...
西南财经大学电子商务学院.doc
11-21
【西南财经大学电子商务学院数据结构考试知识点】 数据结构是一门重要的计算机科学基础课程，主要研究数据的组织方式、存储结构以及在这些结构上执行操作的算法。以下是根据提供的考试题目和选项，提炼出的一些关键...
大连财经学院教学日历共4页.pdf.zip
11-15
【标题】"大连财经学院教学日历共4页.pdf.zip" 涉及的主要知识点是高等教育管理和学术规划，尤其在高等教育机构中如何安排和管理教学进度。教学日历是大学教育的重要组成部分，它包含了学期的开始和结束日期、课程...
浙江财经学院2份大学语文考试题及答案.pdf
08-24
浙江财经学院2份大学语文考试题及答案
【2021ACM-ICPC亚洲区域赛济南站】C、D、J、K四题超详细题解
keguaiguai的博客
02-17 8974
2021ACM-ICPC亚洲区域赛济南站C、D、J、K四题超详细题解
2021河南省第十三届ACM/icpc大学生程序设计竞赛题目
weixin_51534513的博客
05-25 970
2021河南省第十三届ACM大学生程序设计竞赛题目
刷题（一）--数组
降温的博客
07-25 659
二维数组中的查找 题目描述：在一个n*m的二维数组中，每一行都按照从左到右递增的顺序排序，每列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和整数，判断数组中是否含有该整数。 示例： 现有矩阵matrix如下： [ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30] ] 给定target=5，返回
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中.zip
07-31
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中
chromedriver-mac-x64_121.0.6167.184.zip
最新发布
07-31
chromedriver-mac-x64_121.0.6167.184.zip
【Java面试+Java技术文章汇总】 涵盖大部分Java程序员所需要掌握的核心知识。.zip
07-31
【Java面试+Java技术文章汇总】 涵盖大部分Java程序员所需要掌握的核心知识。
资源管理的艺术：使用MySQL用户资源配额优化性能
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
2024版国内外期刊最全信息库（6万多本期刊）(全新整理)
07-31
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/140405010 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 数据指标说明 【包含主要内容】 学科分类状态 期刊语言微信公众号定价邮发代码 期刊名称 电话出版区域邮箱 影响因子[知网]复合影响因子简介 主管部门 出版地址网址自引率[知网]综合影响因子 主办单位 主编 投稿网址国内统一刊号所属分区 是否TOP编辑部 官网微信号官网国际标准刊号地址 传真微信公号期刊等级邮编 是否OA期/掼賁浙鎳验刊状态 是否综述
广西财经学院惠普云平台技术解决方案
"广西财经学院正在寻求通过惠普云平台技术来解决其IT资源利用效率低、信息共享困难的问题。该技术方案旨在构建一个统一的云计算资源平台，以提高效率，降低成本，并提供灵活的资源共享服务架构。" 在《广西财经学院...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值