【2022-09-04】小红书秋招笔试三道编程题

恭喜发现宝藏！搜索公众号【TechGuide】回复公司名，解锁更多新鲜好文和互联网大厂的笔经面经，目前已更新至美团、微软…
作者@TechGuide【全网同名】
点赞再看，养成习惯，您动动手指对原创作者意义非凡🤝

第一题：镜像序列

题目描述

一个序列的生成方式如下：

序列生成需要一个基础序列A，这个序列由n个不大于100的数字组成，同时给定镜像复制次数n。

然后对于A进行m次镜像复制，例如序列A={1，2，3}

则一次镜像复制后得到的序列是{1，2，3，3，2，1）

两次镜像复制得到的序列是B=（1，2，3，3，2，1，1，2，3，3，2，1）。

现在给出你生成一个序列所需要的参数，请你计算该序列的第k位是多少。

输人描述

输入第一行包含三个整数n，m，k，含义如题所示。
（1<=n<=100,1<=m<=60,1<=k<=1e18,部分数据k<10000）

输入第二行包含n个正整数，每个正整数都不大于100，表示基础序列A。
数字间有空格隔开

输出仅包含一个正整数，即序列第k位的数字。

思路

2n长度是循环节，取余之后暴力即可

代码

Python版本

n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
k = (k - 1) % (2 * n)
print((a + a[::-1])[k])
# vx公众号关注TechGuide 实时题库 闪电速递

第二题：乘积为7

题目描述

给定n个整数a1, a2, a3…an。每次操作可以选择其中一个数，并将这个数加上1或者减去1。

小红非常喜欢7这个数，他想知道至少需要多少次操作可以使这n个数的乘积为7？

输入描述

第一行输入一个正整数n，表示整数的个数。

第二行输入n个整数a1, a2, a3…an，其中ai表示第i个数。

5
-6 0 2 -2 3

输出描述

输出一个整数，表示将所有数的乘积变为7最少需要的操作次数。

6

思路

贪心，7是一个素数，必然序列中只能有一个7或者-7，选择绝对值最大的贪心到7或者-7，其余数根据正负贪心到-1或者1。注意如果-1数量是奇数，要把其中一个-1转化到1。
注意：这个算法没有考虑到0的特殊性。比如[-6,0,1]这样的样例可能就不会通过。因为考场上交的时候通过100%就没再看了，应该是数据比较弱给通过了。实际上针对0特殊处理一下就好了，单独处理0，只要有0，那么我们其实不用判断neg变量的奇偶性，因为0可以通过1的代价任意变成-1或者1。

代码

Python版本

n = int(input())
a = list(map(int, input().split()))
# 将最大的数设置为7，或者将最小的数设置为-7
v = max(a, key=abs)
ans = 0
a.remove(v)
neg = 0
if v < 0:
    ans += abs(v + 7)
    neg += 1
else:
    ans += abs(v - 7)

for i in a:
    if i < 0:
        ans += abs(i + 1)
        neg += 1
    else:
        ans += abs(i - 1)
if neg & 1:
    ans += 2
print(ans)
# vx公众号关注TechGuide 实时题库 闪电速递

第三题：最小过路费用

题目描述

小明的旅途中需要经过一个国家。这个国家有n个城市，编号为1到n。小明会从1号城市进入，目标是从n号城市出去（即要从1号城市到达n号城市）。

有m条双向道路连接这n个城市，每条道路的长度都是1，并且都有一个过路费（是[1,100000]之间的整数）。当小明在一号城市时他可以预先花费X的费用办一张特权卡，他可以获得所有过路费不超过X的道路的通行权（而其他道路无法通过）。

小明一天最多只能走k长度的路，他想知道如果他想在一天之内从1号城市到n号城市，他最少需要花费多少来办特权卡，即求X的最小值？

输入描述

第一行是3个整数n，m，k，分别表示城市数，道路数和小明一天最多能走的长度

第二行m个整数，分别为u1, u2…um，分别表示第i条道路的一个端点。

第三行m个整数，分别为v1, v2…vm，分别表示第i条道路的另一个端点。

第四行m个整数，分别为w1, w2…wm，分别表示第条道路的过路费

数字间两两有空格隔开。数据保证一定存在解

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

输出描述

一行一个整数，表示X的最小值

1

思路

显然符合二段性。如果办价格为X的特权卡可以满足，那么使用价格为X+1的特权卡一定也可以满足。二分找到最小符合条件的就可以了

代码

Python版本

from collections import deque, defaultdict

n, m, k = list(map(int, input().split()))
u = list(map(int, input().split()))
v = list(map(int, input().split()))
w = list(map(int, input().split()))

g = defaultdict(dict)

for i in range(m):
    g[u[i]][v[i]] = w[i]
    g[v[i]][u[i]] = w[i]


def check(m):
    q = deque([(1, 0)])
    visited = [False] * (n + 1)
    visited[1] = True
    while q:
        cnt, step = q.popleft()
        if cnt == n: return True
        for nxt, v in g[cnt].items():
            if v <= m and not visited[nxt] and step + 1 <= k:
                q.append((nxt, step + 1))
                visited[nxt] = True

    return False


l = 0
r = max(w)
ans = 0
while l <= r:
    m = (l + r) >> 1
    if check(m):
        ans = m
        r = m - 1
    else:
        l = m + 1
print(ans)
# vx公众号关注TechGuide 实时题库 闪电速递

Java版本

作者：Ddddddf
链接：https://www.nowcoder.com/discuss/1039917
来源：牛客网

import java.util.*;
public class Main {

    static long res = Integer.MAX_VALUE;
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
        int[] u=new int[m];
        int[] v=new int[m];
        int[] w=new int[m];
        Map<Integer, List<Pair>> map = new HashMap<>();
        for (int i = 0; i < m; i++) {
            u[i] = sc.nextInt();
        }
        for (int i = 0; i < m; i++) {
            v[i] = sc.nextInt();
        }
        for (int i = 0; i < m; i++) {
            w[i] = sc.nextInt();
        }
        for (int i = 0; i < m; i++) {
            int a=u[i],b=v[i],value=w[i];
            List<Pair> al = map.containsKey(a) ? map.get(a) : new ArrayList<>();
            List<Pair> bl = map.containsKey(b) ? map.get(b) : new ArrayList<>();
            al.add(new Pair(b, value));
            bl.add(new Pair(a, value));
            map.put(a, al);
            map.put(b, bl);
        }
        int[] vis=new int[m+1];
        dfs(map, 1, n, k, 0, vis, 0);
        System.out.println(res);

    }

    static void dfs(Map<Integer, List<Pair>> map,int cur,int target,int k,long weightSum,int[] vis,int maxWeight){

        if(vis[cur]==1||weightSum>k)
            return;
        if(cur==target&&weightSum<=k){
            res = Math.min(maxWeight, res);
            return;
        }
        vis[cur]=1;
        List<Pair> list=map.get(cur);
        for (Pair pair : list) {
            int tmp = maxWeight;
            maxWeight = Math.max(maxWeight, pair.weight);
            dfs(map, pair.over, target, k ,weightSum + 1, vis,maxWeight);
            maxWeight=tmp;

        }
        vis[cur]=0;
    }

}
class Pair{
    int over;
    int weight;
    public Pair(){}

    public Pair(int over, int weight) {
        this.over=over;
        this.weight = weight;
    }
}
// vx公众号关注TechGuide 实时题库 闪电速递