24年春招/暑期实习-阿里-笔试真题卷(6)

最新推荐文章于 2024-06-27 17:04:15 发布

原创最新推荐文章于 2024-06-27 17:04:15 发布 · 1.2k 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#算法

大厂笔试真题专栏收录该内容

10 篇文章

订阅专栏

第一题：相似数组

在线测评链接：http://121.196.235.151/p/P1158

题目描述

ak机定义两个数组是相似的，当且仅当两个数组的总和相等。

ak机有两个长度为 $n$ 的数组 $a$ 和 $b$ ，ak机想知道有多少个 $i (1 \leq i \leq n)$ 满足将 $a_i$ 翻倍一次后， $a$ 数组和 $b$ 数组是相似的。

输入描述

第一行输入一个整数 $n(1<n≤10^5)$ 表示数组长度

第二行输入 $n$ 个整數表示数组 $a(-10^9≤ a_i≤ 10^9)$

第三行输入 $n$ 个整数表示数组 $b(-10^9≤ b_i< 10^9)$

输出描述

输出可以得到的相似数组的个数

样例

输入

3
1 1 1
1 2 1

输出

思路：模拟

首先，分别统计数组 $a, b$ 的元素总和，记为 $s u m 1, s u m 2$ ，然后我们依次枚举将 $a$ 数组的第 $i$ 个元素翻倍，是否可以使得其总和相等。

注意，本题数据范围较大，C++和Java选手需要开long long

C++

#include<bits/stdc++.h>
using namespace std;
const int N=1E5+10;
int n,a[N],b[N];
int main(){
    cin>>n;
    long long sum1=0,sum2=0;
    for(int i=0;i<n;i++){
        cin>>a[i];
        sum1+=a[i];
    }
    for(int i=0;i<n;i++){
        cin>>b[i];
        sum2+=b[i];
    }
    int cnt=0;
    for(int i=0;i<n;i++){
        if(sum1+a[i]==sum2){
            cnt++;
        }
    }
    cout<<cnt<<endl;

    return 0;
}

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        long sum1 = 0, sum2 = 0;
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
            sum1 += a[i];
        }
        for (int i = 0; i < n; i++) {
            b[i] = scanner.nextInt();
            sum2 += b[i];
        }
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (sum1 + a[i] == sum2) {
                cnt++;
            }
        }
        System.out.println(cnt);
    }
}

Python

n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
sum1 = sum(a)
sum2 = sum(b)
cnt = 0
for i in range(n):
    if sum1 + a[i] == sum2:
        cnt += 1
print(cnt)

第二题：切割绳子

在线测评链接：http://121.196.235.151/p/P1161

题目描述

ak机有 $n$ 根绳子，从1编号到 $n$ ，每根绳子长度为 $a_i$ 。
ak机希望他的绳子们长度相等，他最多切 $k$ 次绳子。

具体的:每次选择一个长度为 $s$ 的绳子，将其切成长度分别为 $x, y$ 的两段

满足: $x, y$ 均为正整数，且 $x + y = s$ 。
他想知道他是否可以切不超过 $k$ 次绳子，从而满足条件，请你帮帮他吧。

输入描述

本题有多组测试数据，输入包含若干行。
第一行一个正整数 $T(1≤T≤104)T(1\le T\le 10^4)$ ，表示数据组数。

接下来，对于每组测试数据:

第一行两个正整数 $10^5),k(0\le k\le 10^{14})$ ，分别表示ak机拥有的绳子个数，以及最多的操作次数。

第二行 $n$ 个正整数 $ai(1≤ai≤109)a_i(1\le a_i\le 10^9)$ ，表示每根绳子的长度。

(保证所有测试数据中 $n$ 的总和不超过 $10^5$ 。)

输出描述

输出包含 $T$ 行，对于每个测试数据，如果ak机可以做到让绳子一样长输出“YES’否则输出“NO”(不包含双引号)。

样例

输入

输出

YES
NO

说明

第一个测试数据:
将第二根绳子切两刀变为:1,1,1，将第三根绳子切一刀变成1,1。此时所有绳子长度都为1
第二个测试数据：
无方案可以满足条件

思路：数论最大公约数

题目要求最终所有的绳子长度都相等，那么我们首先考虑，对于两个绳子来说，如何能保证最终能切成若干个长度相等的绳子？

比如长度为 $4, 2$ 的两根绳子，我们可以切分一次得到 $2, 2, 2$

长度为 $8, 2$ 的两根绳子，我们可以切分3次得到 $2, 2, 2, 2, 2$

长度为 $3, 2$ 的两根绳子，我们可以切分3次得到 $1, 1, 1, 1, 1$

显然，从上面三个例子我们可以得出：对于两个长度分别为 $a, b$ 的绳子，最终一定可以切分成若干个长度为 $c$ 的绳子，且一定满足 $\%c=0且 b \% c=0$

也就是说， $c$ 是 $a, b$ 的约数。那么对于最小分割次数来说，一定是切分成 $a, b$ 的最大公约数

对应的分割次数为 $agcd(a,b)−1+bgcd(a,b)−1\frac{a}{gcd(a,b)}-1+\frac{b}{gcd(a,b)}-1$

那么，以此类推， $n$ 个绳子来说，就是求这 $n$ 个数的最大公约数，然后按照上述分割次数的计算公式求解

我们使用辗转相除法来求最大公约数，对应的复杂度为 $l o g n$

总的时间复杂度为 $O (n l o g n)$

C++

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int a[N],n;
long long k;
int gcd(int x,int y){  //辗转相除法求最大公约数
	return y==0 ? x:gcd(y,x%y);
}

int main(){
	int T;
	cin>>T;
	while(T--){
		cin>>n>>k;
		for(int i=1;i<=n;i++)cin>>a[i];
		int c=a[1];
		for(int i=2;i<=n;i++){
		    c=gcd(c,a[i]);
		}
		long long cnt=0;  //需要的操作次数
		for(int i=1;i<=n;i++){
		    cnt+=(a[i]/c)-1;
		}
		if(cnt>k){
			cout<<"NO"<<endl;
		}else{
			cout<<"YES"<<endl;
		}
	}
	
	return 0;
}

Java

import java.util.*;

public class Main {
    static final int N = 100010;
    static int[] a = new int[N];
    static int n;
    static long k;

    // 辗转相除法求最大公约数
    static int gcd(int x, int y) {
        return y == 0 ? x : gcd(y, x % y);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        while (T-- > 0) {
            n = scanner.nextInt();
            k = scanner.nextLong();
            for (int i = 1; i <= n; i++) {
                a[i] = scanner.nextInt();
            }
            int c = a[1];
            for (int i = 2; i <= n; i++) {
                c = gcd(c, a[i]);
            }
            long cnt = 0;  // 需要的操作次数
            for (int i = 1; i <= n; i++) {
                cnt += (a[i] / c) - 1;
            }
            if (cnt > k) {
                System.out.println("NO");
            } else {
                System.out.println("YES");
            }
        }
    }
}

Python

def gcd(x, y):  # 辗转相除法求最大公约数
    return x if y == 0 else gcd(y, x % y)

T = int(input())
for _ in range(T):
    n, k = map(int, input().split())
    a = list(map(int, input().split()))
    c = a[0]
    for i in range(1, n):
        c = gcd(c, a[i])
    cnt = 0  # 需要的操作次数
    for i in range(n):
        cnt += (a[i] // c) - 1
    if cnt > k:
        print("NO")
    else:
        print("YES")

第三题：武器强化

在线测评链接：http://121.196.235.151/p/P1162

题目描述

ak机有一把武器，初始攻击力为0。现在ak机面前有 $n$ 个强化石，都可以用于强化该武器，每个强化石有一个强化上限 $a_i$ 。

具体的，如果ak机便用第 $i$ 个强化石强化他的武器，那么ak机首先需要选择一个在强化上限以内的非负整数 $x$ 作为强化系数，假设ak机当前武器攻击力为 $k$ ，那么会变为 $k ∣ x$ (其中|表示按位或操作)。接着第 $i$ 个强化石在使用后会失效，即无法再次使用。

ak机想知道，这 $n$ 个强化石最多能使他的武器攻击力强化为多少。

输入描述

本题包含多组测试数据。

第一行输入一个正整数 $T(1≤T≤104)T(1\le T\le 10^4)$ ，表示测试数据组数

接下来，对于每组测试数据，输入包含两行

第一行一个正整数 $n(1≤n≤2×105)n(1\le n\le 2\times 10^5)$ ，表示可以使用的强化石个数

第二行 $n$ 的整数 $ai(0≤ai≤109)a_i(0\le a_i\le 10^9)$ ，表示每个强化石的强化上限。(保证所有测试数据中 $n$ 的总和不超过 $2×1052\times 10^5$ )

输出描述

输出包含 $T$ 行，表示每组测试数据的答案

对于每组测试数据，输出一行一个整数，表示ak机的武器能达到的最大攻击力。

样例

输入

输出

7
1

思路：贪心位运算

本题我们需要对数字按二进制位进行拆解，然后利用或运算的特性来处理

我们知道，对于二进制的第 $i$ 位有

0|0=0
0|1=1
1|1=1

也就是说，我们需要找到一个尽可能高的位置，让其值置为1，这样 $k ∣ x$ 就可以把 $k$ 最大化

以 $k = 1$ 为例

如果 $x=2=(10)_2$ ，第二位为1，因此 $k|x=(11)_2=3$

如果 $x=4=(100)_2$ ，第三位为1，则有 $k|x=(101)_2=5$

如果 $x=5=(110)_2=6$ ，前三位都为1，则有 $k|x=(111)_2=7$

因此，我们可以发现

如果 $x$ 的第 $i$ 位为1，那么 $k ∣ x$ 之后， $k$ 的第 $i$ 位也为1
如果 $x$ 的前 $i$ 位都为1，那么 $k ∣ x$ 之后， $k$ 的前 $i$ 位也都为1

我们可以首先预处理出 $a_i$ 的所有位置 $i(0≤i≤31)i(0\le i\le 31)$ 中含有1的个数，存到一个32位的数组 $c n t$ 中

然后我们从高到低枚举位置，如果当前位置 $c n t [i] > 0$ ，那么首先我们可以让 $k|=2^i$ ，这样就可以将第 $i$ 位设置为1，并且将计数-1

如果当前位置仍然有 $c n t [i] > 0$ ，那么我们可以将 $k|=(2^i-1)$ ，这样就可以将前 $i - 1$ 位都置为1

最终输出 $k$ 即可。

整体的时间复杂度为 $O (32 n)$

C++

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

void solve() {
	int n;
	cin >> n;
	vector<int> cnt(31, 0);
	for (int i = 0, x;i < n;++ i) {
		cin >> x;
		for (int j = 0;j < 31;++ j) if (x >> j & 1) {
			++ cnt[j];
		}
	}
	int ans = 0;
	for (int i = 30; i>=0; -- i) {
		if (cnt[i]) {
			ans |= 1 << i;
			-- cnt[i];
		}	
		if (cnt[i]) {
			ans |= (1<<i) - 1;
			break;
		}
	}
	cout << ans << endl;
}

int main() {
	int T = 1;
	cin >> T;
	while(T --) {
		solve();
	}
}

Java

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

public class Main {
    static int T;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        T = scanner.nextInt();
        while (T-- > 0) {
            solve(scanner);
        }
    }

    public static void solve(Scanner scanner) {
        int n = scanner.nextInt();
        int[] cnt = new int[32];  //统计每一位1的个数
        Arrays.fill(cnt, 0);
        for (int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            for (int j = 0; j < 32; ++j) {
                if ((x >> j & 1) == 1) {  //如果第j位为1
                    ++cnt[j];  //计数+1
                }
            }
        }
        int ans = 0;
        for (int i = 31; i >= 0; --i) {
            if (cnt[i] > 0) {  //如果第i位为1，则直接对2^i进行或操作
                ans |= 1 << i;
                --cnt[i];
            }
            if (cnt[i] > 0) {  //如果还有1,则对(2^i-1)进行或操作
                ans |= (1 << i) - 1;
                break;
            }
        }
        System.out.println(ans);
    }
}

Python

T = int(input().strip())
for _ in range(T):
    n = int(input().strip())
    cnt = [0] * 32  #统计每一位1的个数
    w=list(map(int,input().split()))
    for x in w:
        for j in range(32):
            if x >> j & 1:  #如果第j位为1
                cnt[j] += 1  #计数+1
    ans = 0
    for i in range(31, -1, -1):
        if cnt[i]:  #如果第i位为1，则直接对2^i进行或操作
            ans |= 1 << i
            cnt[i] -= 1
        if cnt[i]:  #如果还有1,则对(2^i-1)进行或操作
            ans |= (1 << i) - 1
            break
    print(ans)