华为4.20笔试
为数不多做的还行的笔试，太菜了
第一题 100%
做题，10道判断 10*2，10道单选 10*4，5道多选 5*8，总共100分。按顺序做，错三个结束。给定分数，问有多少种可能的情况
package huawei;
import java.util.Scanner;
public class Main {
static int ans = 0;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();
dfs(score,1,0);
System.out.println(ans);
}
static void dfs(int target,int i,int wrong){
if(target == 0){
ans++;
return;
}
if(i>25 || wrong >= 3){
return;
}
if(i<=10){
dfs(target-2,i+1,wrong);
dfs(target,i+1,wrong+1);
}else if(i<=20){
dfs(target-4,i+1,wrong);
dfs(target,i+1,wrong+1);
}else if(i<=25){
dfs(target-8,i+1,wrong);
dfs(target,i+1,wrong+1);
}
}
}
第二道题 100%
给两个树的层序遍历数组，和一个替换节点的路径，问替换后的树的层序遍历数组
package huawei;
import sun.reflect.generics.tree.Tree;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
class TreeNode{
int val;
TreeNode left;
TreeNode right;
TreeNode(int _val){
this.val = _val;
this.left = null;
this.right = null;
}
}
public class Main2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String temp = scanner.nextLine();
temp = temp.substring(1,temp.length()-1);
String[] str = temp.split(",");
int[] nums1 = new int[str.length];
for(int i =0;i<str.length;i++) nums1[i] = Integer.parseInt(str[i]);
String[] nodePath = scanner.nextLine().split("/");
int[] nodePathNum = new int[nodePath.length-1];
for(int i = 1;i<nodePath.length;i++) nodePathNum[i-1] = Integer.parseInt(nodePath[i]);
temp = scanner.nextLine();
temp = temp.substring(1,temp.length()-1);
str = temp.split(",");
int[] nums2 = new int[str.length];
for(int i =0;i<str.length;i++) nums2[i] = Integer.parseInt(str[i]);
int k = 1;
TreeNode root = new TreeNode(nums1[0]);
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
if(k<nums1.length && nums1[k]!=0) {
node.left = new TreeNode(nums1[k]);
queue.add(node.left);
}
if(k+1<nums1.length && nums1[k+1]!=0){
node.right = new TreeNode(nums1[k+1]);
queue.add(node.right);
}
k = k +2;
}
k = 1;
TreeNode root2 = new TreeNode(nums2[0]);
queue = new LinkedList<>();
queue.add(root2);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
if(k<nums2.length && nums2[k]!=0) {
node.left = new TreeNode(nums2[k]);
queue.add(node.left);
}
if(k+1<nums2.length && nums2[k+1]!=0){
node.right = new TreeNode(nums2[k+1]);
queue.add(node.right);
}
k = k +2;
}
if(nodePathNum.length>1) {
replace(root,root2,nodePathNum,1);
}else root = root2;
queue = new LinkedList<>();
queue.add(root);
String ans = "[";
while(!queue.isEmpty()){
TreeNode node = queue.poll();
ans = ans + node.val + "," ;
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
ans = ans.substring(0,ans.length()-1) +"]";
System.out.println(ans);
}
static void inorder(TreeNode node){
if(node==null) return;
System.out.println(node.val);
inorder(node.left);
inorder(node.right);
}
static void replace(TreeNode root,TreeNode root2,int[] path,int i){
if(i==path.length-1){
if(root.left!=null && root.left.val == path[i]){
root.left = root2;
return;
}else if(root.right!=null && root.right.val == path[i]){
root.right = root2;
return;
}
}
if(root.left!=null && root.left.val == path[i]){
replace(root.left,root2,path,i+1);
}else if(root.right!=null && root.right.val == path[i]){
replace(root.right,root2,path,i+1);
}
}
}
给定一组服务器的权值及对应父节点，每个服务器的权值既是cost也是贡献，任意两个服务器之前切换的代价为权值差的绝对值。给定一个任务数，问满足任务需求且cost最小的运行路径。
（大概是这么个意思）
package huawei;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main3 {
static int ans = Integer.MAX_VALUE;
static int[] id ;
static int[] pid;
static int[] child;
static Map<Integer,Integer> map = new HashMap<>();
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
id = new int[n];
pid = new int[n];
child = new int[n];
for(int i =0;i<n;i++) child[i] = -1;
for(int i =0;i<n;i++) {
id[i] = scanner.nextInt();
map.put(id[i],i);
}
for(int i =0;i<n;i++) {
pid[i] = scanner.nextInt();
if(pid[i]!=0){
int ind = map.get(pid[i]);
child[ind] = i;
}
}
int target = scanner.nextInt();
for(int i =0;i<n;i++){
boolean[] vis = new boolean[n];
dfs(vis,target-id[i],i,id[i]);
}
ans = ans==Integer.MAX_VALUE?-1:ans;
System.out.println(ans);
}
static void dfs(boolean[] vis,int target,int i,int cost){
vis[i] = true;
if(target <=0){
ans = Math.min(ans,cost);
return;
}else{
int parent = pid[i]==0?-1:map.get(pid[i]);
int children = child[i];
if(parent!=-1 && !vis[parent]){
dfs(vis,target-id[parent],parent,cost + id[parent] + Math.abs(id[i] - id[parent]));
}
if(children!=-1 &&!vis[children]){
dfs(vis,target-id[children],children,cost + id[children] + Math.abs(id[i] - id[children]));
}
}
}
}
