字节跳动春招研发部分编程题汇总做题笔记---Java

3.雀魂启动！

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。
于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：

总共有36张牌，每张牌是1~9。每个数字4张牌。
你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌
14张牌中有2张相同数字的牌，称为雀头。
除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）

例如：

1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头，可以和牌
1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头，组123,123,567,789的四个顺子，可以和牌
1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头，都无法组成和牌的条件。

现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以和牌。

输出描述：

输出同样是一行，包含1个或以上的数字。代表他再取到哪些牌可以和牌。若满足条件的有多种牌，请按从小到大的顺序输出。若没有满足条件的牌，请输出一个数字0

示例1

输入例子：
1 1 1 2 2 2 5 5 5 6 6 6 9
输出例子：
9
例子说明：
可以组成1,2,6,7的4个刻子和9的雀头

示例2

输入例子：
1 1 1 1 2 2 3 3 5 6 7 8 9
输出例子：
4 7
例子说明：
用1做雀头，组123,123,567或456,789的四个顺子

示例3

输入例子：
1 1 1 2 2 2 3 3 3 5 7 7 9
输出例子：
0

思路

遍历可加的九个数，然后进行递归判断。

ac代码

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] card = new int[10];
        for (int i=0;i<13;i++)
            card[in.nextInt()]++;
        ArrayList<Integer> result = new ArrayList<>();
        for (int i=1;i<10;i++){
            if(card[i]>3)
                continue;
            card[i]++;
            if(findRight(card))
                result.add(i);
            card[i]--;
        }
        for (int x:result)
            System.out.print(x+" ");
    }

    public static boolean findRight(int[] card){
        boolean flog = false;
        for (int i=1;i<10;i++){
            // to delete que
                if (card[i]<2)
                    continue;
                card[i]-=2;
                PriorityQueue<Integer> cards = new PriorityQueue<>();
                 Add(cards,card);
                flog = proveRight(cards,card);
                card[i]+=2;
                if (flog)
                    return true;
        }
        return false;
    }

    public static boolean proveRight(PriorityQueue<Integer> cards,int[] card){

        if (cards.isEmpty())
            return true;
        boolean flog = false;
        int now = cards.peek();
            if (card[now]>=3){
                for(int i=0;i<3;i++)
                cards.poll();
                card[now]-=3;
                flog = proveRight(cards,card);
                for(int i=0;i<3;i++)
                cards.add(now);
                card[now]+=3;
            }
            if (flog)
                return flog;
            if (now<=7&&card[now+1]!=0&&card[now+2]!=0)
            {
                for(int i=0;i<3;i++)
                {
                    card[now+i]-=1;
                    cards.remove(now+i);
                }
                flog = proveRight(cards,card);
                for(int i=0;i<3;i++)
                {
                    card[now+i]+=1;
                    cards.add(now+i);
                }
            }
            return flog;
    }
    public static void Add(PriorityQueue<Integer> cards,int[] card){
        for (int i=1;i<10;i++){
            for (int x=1;x<=card[i];x++)
                cards.add(i);
        }
    }
}

4.特征提取

小明是一名算法工程师，同时也是一名铲屎官。某天，他突发奇想，想从猫咪的视频里挖掘一些猫咪的运动信息。为了提取运动信息，他需要从视频的每一帧提取“猫咪特征”。一个猫咪特征是一个两维的vector<x, y>。如果x_1=x_2 and y_1=y_2，那么这俩是同一个特征。
因此，如果喵咪特征连续一致，可以认为喵咪在运动。也就是说，如果特征<a, b>在持续帧里出现，那么它将构成特征运动。比如，特征<a, b>在第2/3/4/7/8帧出现，那么该特征将形成两个特征运动2-3-4 和7-8。
现在，给定每一帧的特征，特征的数量可能不一样。小明期望能找到最长的特征运动。
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32M，其他语言64M
输入描述：
第一行包含一个正整数N，代表测试用例的个数。

每个测试用例的第一行包含一个正整数M，代表视频的帧数。

接下来的M行，每行代表一帧。其中，第一个数字是该帧的特征个数，接下来的数字是在特征的取值；比如样例输入第三行里，2代表该帧有两个猫咪特征，<1，1>和<2，2>
所有用例的输入特征总数和<100000

N满足1≤N≤100000，M满足1≤M≤10000，一帧的特征个数满足 ≤ 10000。
特征取值均为非负整数。

输出描述：

对每一个测试用例，输出特征运动的长度作为一行
示例1

输入例子：

1
8
2 1 1 2 2
2 1 1 1 4
2 1 1 2 2
2 2 2 1 4
0
0
1 1 1
1 1 1

输出例子：

3

例子说明：

特征<1,1>在连续的帧中连续出现3次，相比其他特征连续出现的次数大，所以输出3.

思路

记录帧的所有值，并用一个map保存上一次的帧值，主要技巧在，用String保存两个long数据(其实根据题意无法判断long是否够存，所幸够，要不然在找值的时候需要再堆字符串进行处理)。

ac代码

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int p = in.nextInt();
        while(p-->0){
            int n = in.nextInt();
            int max = Integer.MIN_VALUE;
            HashMap<String,Integer> before = new HashMap<>();
            HashMap<String,Integer> now = new HashMap<>();
            while(n-->0){
                int m = in.nextInt();
                for (int i=0;i<m;i++)
                {
                    long x = in.nextLong();
                    long y = in.nextLong();
                    String now_key = String.valueOf(x)+" "+String.valueOf(y);
                    int now_value = before.getOrDefault(now_key,0)+1;
                    max = Math.max(now_value,max);
                    now.put(now_key,now_value);
                }
                before.clear();
                before.putAll(now);
                now.clear();
                }
            System.out.println(max);
        }
    }
}

5.毕业旅行问题(没做出来，思路贴了参考答案)

小明目前在做一份毕业旅行的规划。打算从北京出发，分别去若干个城市，然后再回到北京，每个城市之间均乘坐高铁，且每个城市只去一次。由于经费有限，希望能够通过合理的路线安排尽可能的省一些路上的花销。给定一组城市和每对城市之间的火车票的价钱，找到每个城市只访问一次并返回起点的最小车费花销。
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32M，其他语言64M
输入描述：
城市个数n（1<n≤20，包括北京）

城市间的车票价钱 n行n列的矩阵 m[n][n]

输出描述：

最小车费花销 s
示例1

输入例子：

4
0 2 6 5
2 0 4 4
6 4 0 2
5 4 2 0

输出例子：

13

例子说明：

共 4 个城市，城市 1 和城市 1 的车费为0，城市 1 和城市 2 之间的车费为 2，城市 1 和城市 3 之间的车费为 6，城市 1 和城市 4 之间的车费为 5，依次类推。假设任意两个城市之间均有单程票可购买，且票价在1000元以内，无需考虑极端情况。

思路

本来想的是进行回溯，后来计算复杂度是n的阶乘，肯定超时，但是没想到好的方法，找到了一个解析是用dp的这里贴一下解答。
思路就是用dp记录做每次加入单个城市路径的记录。
复杂度是O(2的n次方n的平方)
n最大20，10的六次方400 超时边界，基本不会超时。

ac代码

import java.util.*;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
      public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] road = new int[n][n];
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                road[i][j] = in.nextInt();
        // dp[i][j] ,replace the distance of  i to(j) until 0;
        int[][] dp = new int[n][1<<(n-1)];
        for (int i=1;i<n;i++)
            dp[i][0] = road[i][0];
 
        for (int p=1;p<1<<(n-1);p++){
            for (int i=0;i<n;i++){
                dp[i][p] = Integer.MAX_VALUE>>1;
                if (is_p(i,p))
                    continue;
                for (int now=1;now<n;now++){
                    if (is_p(now,p)){
                        int before = find(now,p);
                        dp[i][p] = Math.min(dp[i][p],dp[now][before]+road[i][now]);
                    }
                }
            }
        }
        System.out.println(dp[0][(1<<(n-1))-1]);
    }
 
    public static boolean is_p(int i,int p){   // 0 （为起始或者中间） 这件事一直都对
            return  ((1<<(i-1))&p)!=0;
    }
    public static int find(int i,int p){
//        return (p & (~(1 << (i - 1))));
        return p-(1<<(i-1));
    }
     
}

7

思路：反向求解
如果是H(k+1) > E ，假设跳跃后为E_2，有 E_2 = E - (H(k+1) - E) = 2E - H(K+1);
如果是H(k+1) <= E，假设跳跃后为E_2，有 E_2 = E + (E - H(k+1)) = 2E - H(K+1);
无论哪种情况，最终都有 E_2 = 2E - H(K+1)； -> E = (E_2 + H(k+1) + 1)/2 -> 加一是为了向上取整。

import java.util.Scanner;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] nums = new int[n];
        for(int i=0;i<n;i++)
            nums[i] = in.nextInt();
        long result = 0;
        for(int i=n-1;i>=0;i--){
            result = (result+nums[i]+1)/2;
        }
        System.out.println(result);
}
}