华为2019研发工程师实习生笔试题

问题一：对于给定的字符串，求连续最长回文串的长度。【AC-100%】

思路：将字符串反转，和原字符串求最长连续公共子序列（这样得到的就是最长的连续回文串）的长度即可。

import java.util.Scanner;

public class Main1 {
    public static int solve(String s1) {
        StringBuffer sb = new StringBuffer(s1);
        sb.reverse();
        String s2 = sb.toString();
        int len = s1.length();
        int[][] dp = new int[len+1][len+1];
        for(int i = 0; i <= len; i++)
            dp[i][0] = 0;
        int result = -1;
        for(int i = 1; i <= len; i++) {
            for(int j = 1; j <= len; j++) {
                if(s1.charAt(i-1) == s2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = 0;
                }
                if(dp[i][j] > result)
                    result = dp[i][j];
            }
        }
        return result;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            String str = sc.nextLine();
            System.out.println(solve(str));
        }
    }
}

 

问题二：输入一个URL地址，根据给定的不同URL地址的种类特点（有些 0000:0000 的情况可以简写为 :: ），输出这个地址属于哪一类。【AC-70%】

思路：按照给定的不同种类特点去处理就可以了，简写的情况没有考虑怎么处理，所以没能完全AC=。=

import java.util.Scanner;

public class Main2 {
    public static String solve(String str) {
        String[] x = str.split(":");
        int len = x.length;
        String result = "Error";
        if(str.equals("::")) {
            result = "GlobalUnicast";
        }
        if(str.equals("::1") || str.equals("::0001")) {
            result = "Loopback";
        }
        
        if(x.length == 8) {
            int flag = 0;
            for(int i = 0; i < len-1; i++) {
                if(x[i].length() != 4) {
                    result = "Error";
                    break;
                }
                if(x[i].equals("0000")) {
                    flag++;
                }
            }
            if(flag == 7 && x[7].equals("0001"))
                result = "Loopback";
            if(flag == 7 && x[7].equals("0000"))
                result = "GlobalUnicast";
            
            if(x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='8' || 
               x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='9' ||
               x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='A' ||
               x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='B')
                result = "LinkLocal";
            else if(x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='C' || 
                    x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='D' ||
                    x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='E' ||
                    x[0].charAt(0)=='F' && x[0].charAt(1)=='E' && x[0].charAt(2)=='F')
                result = "SiteLocal";
            else if(x[0].charAt(0)=='F' && x[0].charAt(1)=='F') {
                result = "Multicast";
            } else {
                result = "Unspecified";
            }
        } else {
            
        }
        return result;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            String str = sc.nextLine();
            System.out.println(solve(str));
        }
    }
}

 

问题三：按照APP排名顺序，给出下载每个APP需要消耗的流量和可以获得的金币，问在给定流量下，如何下载APP使获得的金币最多，下载一个APP至多获得一次金币；相同金币下，下载排名高的。AC-100%

思路：0-1背包问题，需要记录路径，可以用一个二维数组，相同情况下选择排名高的处理方式为：从后往前遍历，遇见价值大于或者相同的都更新，即 >= 时更新

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

public class Main3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int M = sc.nextInt();
            sc.nextLine();
            String appInput = sc.nextLine();
            String coinInput = sc.nextLine();
            String[] apptmp = appInput.split("\\s+");
            String[] cointmp = coinInput.split("\\s+");
            int N = apptmp.length;
            int[] app = new int[N+1];
            int[] coin = new int[N+1];
            
            for(int i = 1; i <= N; i++) {
                app[i] = Integer.parseInt(apptmp[i-1]);
            }
            for(int i = 1; i <= N; i++) {
                coin[i] = Integer.parseInt(cointmp[i-1]);
            }
            
            int[] dp = new int[M+1];
            int[][] path = new int[N+1][M+1];
            for(int i = 1; i <= N; i++) {
                for(int j = M; j >= 0; j--) {
                    if(j >= app[i]) {
                        if(dp[j] < dp[j-app[i]] + coin[i]) {
                            dp[j] = dp[j-app[i]] + coin[i];
                            path[i][j] = 1;
                        }
                    }
                }
            }
            ArrayList<Integer> ans = new ArrayList<>();
            int x = N, y = M;
            while(x > 0 && y > 0) {
                if(path[x][y] == 1) {
                    ans.add(x);
                    y -= app[x];
                }
                x--;
            }
            Collections.sort(ans);
            for(int i = 0; i < ans.size(); i++) {
                if(i == 0)
                    System.out.print(ans.get(i));
                else
                    System.out.print(" " + ans.get(i));
            }
            System.out.println();
        }
    }
}