3.23华为机考

机考第一题
跳跃游戏二
在具体的实现中，我们维护当前能够到达的最大下标位置，记为边界。我们从左到右遍历数组，到达边界时，更新边界并将跳跃次数增加 1。

在遍历数组时，我们不访问最后一个元素，这是因为在访问最后一个元素之前，我们的边界一定大于等于最后一个位置，否则就无法跳到最后一个位置了。如果访问最后一个元素，在边界正好为最后一个位置的情况下，我们会增加一次「不必要的跳跃次数」，因此我们不必访问最后一个元素。

class Solution {
    public int jump(int[] nums) {
        int length = nums.length;
        int end = 0;
        int maxPosition = 0; 
        int steps = 0;
        for (int i = 0; i < length - 1; i++) {
            maxPosition = Math.max(maxPosition, i + nums[i]); 
            if (i == end) {
                end = maxPosition;
                steps++;
            }
        }
        return steps;
    }
}

机考第二题
先对字符串进行判断，每个合法的由有3个部分，tag号，字节长度，后面的字符，注意字节长度*2才是真正长度，如何是合法的就截取下来，在进行判断，最后输出tag号和偏移长度。

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>

using namespace std;
int hexToDec(const string& str);
int main()
{
    //输入
    string strTLV;
    int nTag;
    cin>>strTLV;
    cin>>nTag;
    vector<int> tag(nTag);
    for (int i=0; i<nTag; i++){
        cin >> tag[i];
    }

    //结束输入
    unordered_map<int, pair<int, int>> ump;
    int i=0;
    bool goodTLV=true;
    while (i<strTLV.size()-1&&goodTLV){
        if (i+4>strTLV.size()) break;
        int curTag=hexToDec(strTLV.substr(i,2));
        int length=hexToDec(strTLV.substr(i/2+2,2));
        //检测是否是完整的TLV
        if (i+length*2+4>strTLV.size()){
            goodTLV=false;
            break;
        }
        //如果是，加入数据
        ump[curTag].first=length;
        ump[curTag].second=i+2;
        i=i+length*2+4;
    }
    for (int i=0; i<nTag; i++){
        if (ump.find(tag[i])!=ump.end()){
            cout << ump[tag[i]].first << ' ' << ump[tag[i]].second << endl;
        }
        else {
            cout << 0 << ' ' << 0 << endl;
        }
    }

    return 0;
}
int hexToDec(const string& str)
{
    if (str.size()!=2) return -1;
    int ret=0;
    if (str[1]>='A') ret+=str[1]-'A'+10;
    else ret+=str[1]-'0';
    if (str[0]>='A') ret+=(str[0]-'A'+10)*16;
    else ret+=(str[0]-'0')*16;
    return ret;
}

第三题想的方法是dfs深度优先遍历，如果面试官能够将候选者面掉，则标记面试官和候选者，继续深度优先遍历，如果不满足就跳过面试下一个
dfs结束条件：格点越过右下角最后一格，此时需要判断本次遍历是否匹配成功
判断成功条件：条件1：各行不能大于k 条件2：各列必须等于2

import java.util.ArrayList;
import java.util.Scanner;



public class Main{
    static int M, N, k;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        M = sc.nextInt();
        N = sc.nextInt();
        k = sc.nextInt();
        sc.nextLine();
        //list存放第m位面试官会的语言，如list.get(0)存放第1位面试官的语言，String[]数组存放，长度不定
        ArrayList<String[]> list = new ArrayList<>();
        //mat矩阵存放面试官与受试者语言匹配关系，第m位面试官会第n位受试者的语言，则mat[m][n]=1，否则设为0
        int[][] mat = new int[M][N];
        //res为面试官与受试者是否要去匹配的矩阵。在递归中会对该矩阵的值进行更新
        // 若mat[m][n]=0,则由于不匹配，res[m][n]===0，
        // 否则res[m][n]可通过设置0/1表示 不匹配/匹配。
        int[][] res = new int[M][N];

        //读取面试官会的语言
        for (int i = 0; i < M; i++) {
            list.add(sc.nextLine().split(" "));
        }
        //下面代码边读取第i位受试者边填充第i列mat矩阵，遇到可以匹配的面试官就将值设为1
        for (int i = 0; i < N; i++) {
            String lg = sc.nextLine();  //读取i号受试者会的语言
            for (int j = 0; j < M; j++) {
                for (String str : list.get(j)) {    //遍历当前面试官语言
                    if (str.equals(lg)) {
                        mat[j][i] = 1;
                    }
                }
            }
        }
        int NN = N;
        boolean flag = backTrack(res, mat, NN,0, 0, 2); //block指的是当前遍历到的格点位置，遍历方式：从左到右+1，到达最右端换行
        System.out.println(flag);
        if(flag){
            for(int i = 0;i<res.length;i++){
                for(int j = 0;j<res[0].length;j++){
                    System.out.print(res[i][j]+",");
                }
                System.out.println();
            }
        }
    }
    //n代表在对哪一个学生进行判断，为0结束(第N-n位)；count表示当前学生面试数量； start表示对哪一位老师进行检测
    public static boolean backTrack(int[][]res, int[][]mat, int n, int count, int start, int target){
        if(n==0){
            return true;
        }
        if(count==target) return backTrack(res, mat, n-1, 0, 0, target);

        for(int i = start; i < M; i++){
            if(mat[i][N-n]!=1) continue;
            if(!check(res,i)) continue;

            System.out.println("i:"+i+",N-n:"+(N-n));
            res[i][N-n] = 1;

            if(backTrack(res, mat, n, count+1, i+1, target)) return true;

            res[i][N-n] = 0;
        }

        return false;
    }

    //检验老师是否已经面试了k个学生了
    private static boolean check(int[][] res, int row) {

        int count = 0;
        for(int j = 0;j<N;j++){

            count += res[row][j];
        }
        return count<k;
    }

}