小红书5-7后端笔试题，不算太难

小明数列
        时间限制： 1000MS
        内存限制： 65536KB
        题目描述：
        小明了解了递归函数，十分喜欢递归这一概念。他用递归的概念定义了一个数列{an}，其中a0和a1均为1，对于i≥2，

        ai=ai-1*A+ai-2*B。递归定义让小明十分开心，但是算起来却很痛苦，现在小明想让你帮他算一算。考虑到数列可能很大，小明觉得你告诉他对应项模上M之后的答案就可以了（数列中的每一个数叫做这个数列的项）。



        输入描述
        第一行三个数A，B，M，含义见题面。

        接下来一行一个数Q，表示小明询问次数。

        接下来一行Q个数q1,q2,...,qQ，第i个数qi表示小明第i次询问数列第qi项模上数字M后的答案。

        对于所有数据，1≤Q,qi≤50000，1≤A,B,M≤108

        输出描述
        一行Q个数，依次表示每次答案。


        样例输入
        1 1 4
        4
        1 2 3 4
        样例输出
        1 2 3 1

        提示
        样例解释

        ① a1=1

        ② a2=a0+a1=2

        ③ a3=a1+a2=3

        ④ a4=a2+a3=5

        但是都要对 4 取模，因此答案分别为1 2 3 1

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

long long s[50005];
long long a, b, m;

void f(int i) {
	if (i == 50003)
		return;
	s[i] = ((s[i - 1] * a) % m + (s[i - 2] * b) % m) % m;
	f(i + 1);
}

int main () {
	int q, qi;
	s[0] = 1;
	s[1] = 1;
	scanf("%lld %lld %lld", &a, &b, &m);

	f(2);
	scanf("%d", &q);
	for (int i = 0 ; i < q; i++) {
		scanf("%d", &qi);
		printf("%lld\n", s[qi]);
	}
}

最大最小值
        时间限制： 1000MS
        内存限制： 65536KB
        题目描述：
        有一个长度为n的序列，其中第i个元素ai，你现在可以对这个序列进行最多k次操作，每次可选择一个连续的区间将其中的元素删掉，但剩余的元素个数必须大于0。 现在想让剩余元素的最小值尽可能大，求上述情况下的最大值。



        输入描述
        第一行两个正整数n和k，分别表示初始序列中元素的个数以及最多的操作次数。

        接下来1行，n个正整数，其中第i个数为ai。

        对于所有数据，1<=n<=10^5，0<=k<=10^5，1<=ai <=10^6。

        输出描述
        输出仅包含一个正整数，表示答案。


        样例输入
        8 1
        58 57 86 89 25 26 61 42
        样例输出
        58

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

int main() {
	int n, k;
	int a[1000005];
	scanf("%d %d", &n, &k);
	int minv = 0x3f3f3f3f, minp, maxv = 0, maxp;
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
		if (minv > a[i]) {
			minv = a[i];
			minp = i;
		}
		if (maxv < a[i]) {
			maxv = a[i];
			maxp = i;
		}
	}
	if (k >= 2) {
		printf("%d\n", maxv);
	} else if (k == 0) {
		printf("%d\n", minv);
	} else {
		k == 1
		if (maxp == 0 || maxp == n - 1) {
			printf("%d\n", maxv);
		} else {
			if (minp > maxp) {
				int secondsmall = 0x3f3f3f3f;
				for (int i = 0; i < n; i++) {
					if (a[i] < secondsmall && a[i] != minv) {
						secondsmall = a[i];
					}
				}
				int boundv  = max(a[0], a[n - 1]);
				if (boundv > secondsmall) {
					printf("%d\n", boundv);
				} else {
					int maxx = 0;
					for (int i = 0; i < maxp; i++) {
						if (maxx < a[i]) {
							maxx = a[i];
						}
					}
					printf("%d\n", maxx);
				}
			} else if (minp < maxp) {
				int secondsmall = 0x3f3f3f3f;
				for (int i = 0; i < n; i++) {
					if (a[i] < secondsmall && a[i] != minv) {
						secondsmall = a[i];
					}
				}
				int boundv  = max(a[0], a[n - 1]);
				if (boundv > secondsmall) {
					printf("%d\n", boundv);
				} else {
					int maxx = 0;
					for (int i = maxp + 1; i < n; i++) {
						if (maxx < a[i]) {
							maxx = a[i];
						}
					}
					printf("%d\n", maxx);
				}
			} else {
				printf("%d\n", maxv);
			}
		}
	}
}

球
        时间限制： 3000MS
        内存限制： 589824KB
        题目描述：
        小明有很多个袋子，每个袋子里都装了一些彩色的球。

        现在小明想知道他的这些袋子是否同时满足以下三个条件：

        1. 对于每个袋子，其中的球颜色两两不同。

        2. 每个袋子都装着相同数量的球。

        3. 对于每一种颜色，其要么仅出现在一个袋子中要么出现在所有袋子中。



        输入描述
        第一行有一个正整数T(1<=T<=10)，代表有多少组测试数据。接下来是T组测试数据，每组由数行构成。

        每一组测试数据的第一行有一个数n(2<=n<=100)，代表小明有多少个袋子。接下来的n行每行代表一个袋子。

        接下来n行每一行的开头有一个数c(1<=c<=100)，代表这个袋子中的球数。在c之后有c个正整数，分别代表这个袋子中每个球的颜色。

        颜色编号均为0到2^32-1之间的非负整数。

        输出描述
        对于每组测试数据，如果小明的这些袋子满足全部三个条件，则在一行中先输出Yes，然后按编号大小输出所有袋子共有的颜色编号。在这种情况下如果没有一种颜色为所有袋子共有，则直接换行。

        如果小明的这些袋子不满足以上的至少一个条件，则输出No。


        样例输入
        4
        3
        4 3 5 8 6
        4 2 6 4 5
        4 6 7 1 5
        3
        4 4 5 8 6
        4 2 6 4 5
        4 6 7 1 4
        3
        2 1 2
        2 3 4
        2 5 6
        3
        2 1 2
        2 2 1
        2 1 2
        样例输出
        Yes 5 6
        No
        Yes
        Yes 1 2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();


        while(t-- > 0) {
            int markNum = -1;
            boolean gg = false;
            HashSet<Long> hashSet = null;
            HashMap<Long, Integer> hashMap = new HashMap<>();
            int n = in.nextInt();
            for(int i = 0; i < n; i++) {
                int num = in.nextInt();
                if(markNum != -1 && num != markNum) {
                    gg = true;// 条件2
                    //System.out.println("条件2");
                }
                markNum = num;
                hashSet = new HashSet<>();
                for(int j = 0; j < num; j++) {
                    long a = in.nextLong();
                    if(hashSet.contains(a)) {
                        gg = true;// 条件1
                        //System.out.println("条件1");
                    }
                    hashSet.add(a);
                    hashMap.put(a, hashMap.getOrDefault(a, 0) + 1);
                }
            }
            List<Long> ans = new ArrayList<>();
            Collections.sort(ans);
            for(Map.Entry<Long, Integer> entry : hashMap.entrySet()) {
                int v = entry.getValue();
                if(v != 1 && v != n) {
                    gg = true;// 条件3
                    //System.out.println("条件3");
                    break;
                }
                if(v == n) {
                    ans.add(entry.getKey());
                }
            }

            if(gg) {
                System.out.println("No");
            } else {
                System.out.print("Yes");
                if(ans.size() != 0) {
                    for(int k = 0; k < ans.size(); k ++) {
                        System.out.print(" " + ans.get(k));
                    }
                }
                System.out.println();
            }
        }

    }
}