Java实现蓝桥杯第六届2015年真题

最新推荐文章于 2022-03-23 10:38:20 发布
最新推荐文章于 2022-03-23 10:38:20 发布
阅读量346 收藏 1
点赞数
分类专栏： 蓝桥杯真题 文章标签： dfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/104891268
版权

蓝桥杯第六届2015年真题

题目用到知识点/算法类型
三角形面积水题
立方变自身数学知识+枚举
三羊献瑞数学知识+枚举
循环节长度dfs
九数组分数凑算式类dfs
加法变乘法数学知识+枚举
牌型种数排列组合类dfs
饮料换购数学知识+递归 或直接枚举
垒骰子dfs暴力搜 优化用dp 再优化用矩阵乘法+快速幂
生命树自定义数据结构+dfs+回溯

三角形面积

如【图1】所示。图中的所有小方格面积都是1。
那么，图中的三角形面积应该是多少呢？
在这里插入图片描述
请填写三角形的面积。不要填写任何多余内容或说明性文字。

初中数学题
答案：
28

立方变自身

题目描述
观察下面的现象,某个数字的立方，按位累加仍然等于自身。
1^3 = 1 
8^3  = 512    5+1+2=8
17^3 = 4913   4+9+1+3=17
...

请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？

请填写该数字，不要填写任何多余的内容或说明性的文字。
 答案：6
1 1
8 8
17 17
18 18
26 26
27 27

【思路】
立方后的数字每位最多只能是9，也就是说按位和最大不会超过99。
99的立方数是6位。那按位和最大是6* 9 = 54。实际上也就是说符合这一性质的数在54以内。

package 第六届;

public class t02_立方变自身 {
	static int sum(int i) {
		String s=String.valueOf(i);
		int res=0;
		//按位求和
		for(int j=0;j<s.length();j++) {
			res=res+(s.charAt(j)-'0');
		}
		//System.out.println("i="+i+" "+res);
		return res;
	}
	public static void main(String[] args) {
		//根据数学性质 符合这一性质的正整数不会超过99
		int cnt=0;
		for(int i=1;i<99;i++) {
			int i1=i*i*i;
			if(sum(i1)==i) {
				cnt++;
				System.out.println(i+" "+sum(i1));
			}
		}
		System.out.println(cnt);
	}

}

三羊献瑞

题目描述


观察下面的加法算式：

      祥 瑞 生 辉
  +   三 羊 献 瑞
-------------------
   三 羊 生 瑞 气

(如果有对齐问题，可以参看【图1.jpg】)

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。

答案： 1085

填空题 枚举暴力搜索解决

package 第六届;

public class t03_三羊献瑞 {

	public static void main(String[] args) {
	//		d c e f
	//		1 a b c
	//    1 a e c g
		//1 a  
		for(int a=0;a<=9;a++) {
			if(a==1)continue;
			for(int b=0;b<=9;b++) {
				if(b==1)continue;
				for(int c=0;c<=9;c++) {
					if(c==1)continue;
					for(int d=2;d<=9;d++) {
						if(d==1)continue;
						for(int e=0;e<=9;e++) {
							if(e==1)continue;
							for(int f=0;f<=9;f++) {
								if(f==1)continue;
								for(int g=0;g<=9;g++) {
									if(g==1)continue;
									if(a!=b&&a!=c&&a!=d&&a!=e&&a!=f&&a!=g
											&&b!=c&&b!=d&&b!=e&&b!=f&&b!=g&&
											c!=d&&c!=e&&c!=f&&c!=g&&
											d!=e&&d!=f&&d!=g&&
											e!=f&&e!=g
											&&f!=g
											) {
										int x=1000+a*100+b*10+c;
										int y=d*1000+c*100+e*10+f;
										int z=10000+a*1000+e*100+c*10+g;
										if(x+y==z) {
											//System.out.println("1"+a+" "+b+" "+c);
											System.out.println(x+" "+y+" "+z);
											}
										}
									}
							}
						}
					}
				}
			}
		}
	}

}

【思路】
毋庸置疑， “三”肯定是数字1。9个数字选全排列选7个然后check

祥 瑞 生 辉 羊 献 气
对应
数组[0] [1] [2] [3] [4] [5] [6] [7]

  祥 瑞 生 辉
  • 三 羊 献 瑞

三 羊 生 瑞 气

package 第六届;


/**
* @author JohnnyLin
* @version Creation Time：2021年4月13日 上午11:41:16

*/
public class t03_三羊献瑞2 {
	static int N = 10;
	static int f[] = new int [N];
	static boolean st[] = new boolean[N];
	public static void  dfs(int u) {
		if( u == 7) {
			int a = f[0] * 1000 + f[1] *100 + f[2]* 10+ f[3];
			int b = 1000 + f[4] * 100 + f[5] * 10 + f[1];
			int c = 10000 + f[4]* 1000 + f[2]*100 + f[1]*10 +f[6];
			if( a+ b == c ) {
				System.out.println(a + " "+ b +" "+ c); // 9567 1085 10652
			}
		}
		for(int i = 0; i <= 9; i ++)
			if( !st[i]) {
				st[i] = true;
				f[u] = i;
				dfs(u + 1);
				st[i] = false;
			}
		
	}
	public static void main(String[] args) {
		st[1] =  true;
		dfs(0);
		
	}

}

循环节长度

【思路】
vector数组中不断加入被除数，如果出现一样的被除数那么就是一段循环节。

/*


两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153 846153.....  其循环节为[846153] 共有6位。 
 */
/*

循环节长度

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153 846153.....  其循环节为[846153] 共有6位。 
 */
package 第六届;

import java.util.Vector;

public class t04_循环节长度 {

	public static int f(int n, int m)
	{
		n = n % m;	
		Vector v = new Vector();
		//for()
		for(;;)
		{
			v.add(n);
			n *= 10;
			n = n % m;
			if(n==0) return 0;
			//说明找到重复的被除数
			//那么两个位置之间就是一个循环节长度
			if(v.indexOf(n)>=0)  return v.size() -  v.indexOf(n) ;  //填空
		}
	}
	public static void main(String[] args) {
		System.out.println(f(11,13)); //0.846153 846153 ……
		System.out.println(f(7,18)); // 0.3888888888888……
		System.out.println(f(10,3)); //3.333333333333333
		System.out.println(f(9,11)); //0.8181818181……
	}

}

九数组分数


1,2,3...9 这九个数字组成一个分数，其值恰好为1/3，如何组法？

思路：九位数字组成一个分数1/3 只能是分母5位，分子4位
答案：
5823 17469
5832 17496


package 凑算式类;

public class 九数组分数 {
	//分子为四位数 分母为五位数
	static int[] a=new int[9];
	static boolean[] vis=new boolean[10];
	static boolean f;
	static void dfs(int index) {//表示试填第index位
//		if(f) {
//			return;
//		}
		//在这里输出结果否则存放在数组中的结果可能在return后被修改了
		if(index == 9) { //凑到了最后一位
		    int s = (a[0]*1000+a[1]*100+a[2]*10+a[3]);
		    if(s*3 == a[4]*10000+a[5]*1000+a[6]*100+a[7]*10+a[8]) {//目标是要算式成立
		        System.out.println(s+" "+s*3);
		       // f=true;
		        }
		    return;
		}

		for(int i=1;i<=9;i++) {//枚举1-9填入index位
			if(!vis[i]) {//该数字没有用过
				//标记为用过
				vis[i]=true;
				a[index]=i;
				//System.out.println(i+" "+index);
				dfs(index+1);
				vis[i]=false;
			}
		}
	}
	public static void main(String[] args) {
		dfs(0);
	}
}

加法变乘法

/*
加法变乘法
我们都知道：1+2+3+ ... + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：
1+2+3+4+5+6...7+8+9+10*11+12+...+27*28+29+...46+47+48+49 = 2015
就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
 */

package 第六届;

public class t06_加法变乘法 {
	static int sum(int s,int t,int []nums) {
		if(s<1||s>49||t>49) return 0;
		int res=0;
		for(int i=s;i<=t ;i++) {
			res+=nums[i];
		}
		return res;
	}
	public static void main(String[] args) {
		//0 1 49
		int []nums=new int[50];
		for(int i=1;i<=49;i++) {
			nums[i]=i;
		}
		//第一个乘号最多只能到46后面
		for(int i=1;i<=46;i++) {
			//第二个乘号最多只能到48后面
			for(int j=i+2;j<=48;j++) {
				int s3=0,s4=0,s5=0;
				int s1=nums[i]*nums[i+1];
				if(i>1) {
					s5=sum(1,i-1,nums);
				}
				if(i+2!=j) {
					s3=sum(i+2,j-1,nums);
				}
				if(j+1>49) continue;
				int s2=nums[j]*nums[j+1];
				s4=sum(j+2,49,nums);
				if(s1+s2+s3+s4+s5==2015) {
					System.out.println(nums[i]);
					System.out.println(nums[j]);
				}
			}
		}
	}

}

解法二、运用点数学方法巧算

package 第六届;

public class t06_加法变乘法2 {

	public static void main(String[] args) {
	
		//第一个乘号最多只能到46后面
		for(int i=1;i<=46;i++) {
			//第二个乘号最多只能到48后面
			for(int j=i+2;j<=48;j++) {
				//参与乘法运算的只有四项 分别为i i+1 和j j+1
				//其余皆为加法 说明原式子与最终式子的差值是这四项造成的 1225为1~49之和
				if( i*(i+1)-(i+i+1)+j*(j+1)-(j+j+1)==2015-1225 ) {
					System.out.println(i+" "+j );
				}
			}
		}
	}

}

牌型种数


小明被劫持到X赌城，被迫与其他3人玩牌。一副扑克牌（去掉大小王牌，共52张），
均匀发给4个人，每个人13张。这时，小明脑子里突然冒出一个问题：如果不考虑
花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌
型组合一共有多少种呢？

思路

dfs
答案: 3598180

写法一：
package 排列组合;
//总共13种牌A到K，每种可以选0到4张，总共选出13张，两个13如果简单表示的话就是2 13
public class 牌型种数 {
	public static int count = 0 ;
	public static void dfs(int type, int sum) {
		// 结束条件
		if(type == 13) { //列举完牌数种类 A到K  13类
			if(sum == 13) { //目标要凑够13张
				count++;
			}
			return;
		}
		// 搜索
		for(int i=0; i<=4; i++) {
			dfs(type+1, sum+i); // 此解法的关键，就在于sum+i 而不是sum+1
		}
	}

	public static void main(String[] args) {
		dfs(0,0);
		System.out.println(count);
	}


}

写法二：
package 排列组合;
public class 牌型种数2 {
	public static int count = 0 ;
	public static int[] a = new int[13];
	public static void dfs(int index) {
		if(index == 13) {
			int sum = 0;
			for(int i : a) {
				sum += i;
			}
			if(sum == 13) {//牌总数达到13张
				count++;
			}
			return;
		}
		// 搜索
		for(int i=0; i<=4; i++) {
			a[index] = i;//i个index类的牌
			dfs(index+1); 
		}
	}

	public static void main(String[] args) {
		dfs(0);
		System.out.println(count); 
	}

}

饮料换购


饮料换购

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。

输入：一个整数n，表示开始购买的饮料数量（0<n<10000）
输出：一个整数，表示实际得到的饮料数

例如：
用户输入：
100
程序应该输出：
149

用户输入：
101
程序应该输出：
151


资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms

递归写法：

package 第六届;

import java.util.Scanner;

public class t08_饮料换购 {
	static  int ans;
	//
	static void dfs(int n,int sum) {
		//但最后一次换购要注意
		if(n<3) {
			System.out.println(ans+sum);
			System.exit(0);
		}
		//3个瓶盖可以再换一瓶 等价为每两瓶换得一瓶
		dfs(n-2,sum+1);
	}

	public static void main(String[] args) {
		//原先有n瓶饮料 兑换得到的饮料数
		Scanner reader=new Scanner(System.in);
		int n=reader.nextInt();
		ans=n;
		dfs(n,0);
	}

}

饮料换购

迭代写法：

package 第六届;

import java.util.Scanner;

public class t08_饮料换购2 {
	

	public static void main(String[] args) {
		//原先有n瓶饮料  即有n个瓶盖
		Scanner reader=new Scanner(System.in);
		int n=reader.nextInt();
		int ans=0;
		while(n>2) {
			ans+=3;
			//每两个瓶盖换一瓶
			n-=2;
		}
		ans=ans+n;
		System.out.println(ans);

	}

}

【思路】
递归 + 直接枚举
比较容易的写法 与汉诺塔写法类似

import java.util.Scanner;
class Main{
    /**
     * n 瓶盖数
     */
    public static int dfs(int n){
        if( n < 3) return 0;
        return n / 3 + dfs( n/3 + n %3);//不要忽略了换得的n / 3瓶的瓶盖哦
    }
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        int n = reader.nextInt();
        System.out.println(n + dfs(n) );
        
    }
}

相似题： 题目 1072: 汽水瓶
不一样的地方在于可以先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板

import java.util.Scanner;

public class Main {
    public static int dfs(int n){
        if( n < 2) return 0;
        if( n == 2) return 1;
        return n / 3 + dfs(n / 3 + n % 3); 
        
    }
	public static void main(String[] args) {
		Scanner reader = new Scanner(System.in);
	    
	    while(true){
	        int n = reader.nextInt();
	        if( n == 0) break;
	        System.out.println( dfs(n));
	    }
	    
	}
}

垒骰子

解法一、dfs暴力法

题目描述
垒骰子
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，
要垒成方柱体。经过长期观察，atm 发现了稳定骰子的奥秘；有些数字的面贴着
会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。
不要小看了 atm 的骰子数量哦～

「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。

「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。

「样例输入」
2 1
1 2
「样例输出」
544

这种暴力法只能提交到oj上只能通过30%的数据

package 第六届;

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

public class 垒骰子 {
	static final long mod=1000000000+7;
	static int [][]a;
	static int atm[];
	//骰子对面 1-4  2-5 3-6
	static int duimian[]= {0,4,5,6,1,2,3};
	static int n;
	static long ans;
	static ArrayList []huchi;
	static long mypow(int x,int y) {
		long res=1;
		for(int i=1;i<=y;i++) {
			res*=x;
		}
		return res;
	}
	static void dfs(int r) {
		if(r==n) {
			ans++;
			return;
		}
		for(int i=1;i<=6;i++) {
			if(r>=1) {
				if(!huchi[ atm[r-1] ].contains(i)) {
					atm[r]=i;
					dfs(r+1);
				}
			}
			else {
				atm[r]=i;
				dfs(r+1);				
			}
		}
	}
	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		//n个骰子
		n=reader.nextInt();
		//m组互斥对
		int m=reader.nextInt();
		a=new int[m][2];
		atm=new int[n];
		huchi=new ArrayList[7];
		for(int i=1;i<=6;i++) {
			huchi[i]=new ArrayList();
		}
		//1 2 5
		//2 1 4
		//4*4  
		/*用链表记录互斥对数字
		 * 1-4  2-5 3-6
		 */
		for(int i=0;i<m;i++) {
			int x=reader.nextInt();
			int y=reader.nextInt();			
			huchi[x].add(duimian[y]);
			huchi[y].add(duimian[x]);
		}
		dfs(0);
		//因为每个骰子四个面对应四种不同结果，所以还要乘上4^n
		//原题目：两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
		ans=( mypow(4,n)*ans)%mod;
		System.out.println(ans);
	}
	
}

解法二、dp解法

提交到oj上也只能过70%的数据

package 第六届;

import java.util.Scanner;

public class 垒骰子_动态规划 {
	static final int mod=1000000000+7;
	
	static long mypow(int x,int y) {
		long res=1;
		for(int i=1;i<=y;i++) {
			res*=x;
		}
		return res;
	}
	
	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		//n个骰子
		int n=reader.nextInt();

		int m=reader.nextInt();
		//对立面
		int [] op=new int[] {0,4,5,6,1,2,3};

		//m组互斥对
		boolean [][] confilct=new boolean[7][7];
		for(int i=0;i<m;i++) {
			int x=reader.nextInt();
			int y=reader.nextInt();
			confilct[x][y]=true;
			confilct[y][x]=true;
		}
		//dp[i][j] 表示第i层 该层朝上数字为j时的可行方案数
		//由图中的递推式可知本层方案数目只与上一层有关 故可以用两行的动态数组保存方案数
		int [][] dp=new int[2][7];
		for(int i=1;i<=6;i++) {
			dp[0][i]=1;
		}
		//迭代的层数	
		for(int i=1;i<n;i++) {
			//面朝上的数字
			for(int j=1;j<=6;j++) {
				for(int x=1;x<=6;x++) {
					if(confilct[j][ op[x] ]) continue;
					dp[ i%2 ][j]=(dp[ i%2 ][j]+dp[(i-1)%2 ][x]);
				}
			}
		}
		long ans=0;
		for(int i=1;i<=6;i++) {
			ans+=dp[(n-1)%2][i];
		}
		ans=mypow(4,n)*ans%mod;
		System.out.println(ans);
		
	}
	
}

动态规划解法

解法三、矩阵快速幂

提交到oj上 终于可以全部通过了 关于矩阵的乘法运算和快速幂可以参考我的文章

package 第六届;
import java.util.Scanner;

public class 垒骰子_矩阵乘法 {
	static int [] op=new int[7];
	static int n,m;
	private static final long mod=1000000000+7;
	static void init() {
		op[1]=4;
		op[2]=5;
		op[3]=6;
		op[4]=1;
		op[5]=2;
		op[6]=3;
	}

	public static void main(String[] args) {
		init();
		Scanner reader=new Scanner(System.in);
		n=reader.nextInt();
		m=reader.nextInt();
		long conflict[][]=new long[6][6];
		for(int i=0;i<6;i++) {
			for (int j = 0; j < 6; j++) {
				conflict[i][j]=1;
				}
			}
		//建立冲突矩阵
		for(int i=0;i<m;i++) {
			int x=reader.nextInt();
			int y=reader.nextInt();
			conflict[ op[x]-1 ][y-1]=0;
			conflict[ op[y]-1 ][x-1]=0;
		}
		//求冲突矩阵的n-1次方
		long [][] mPow_n_1=mPow(conflict,n-1);
		//累加mPow_n_1矩阵
		long ans=0;
		for(int i=0;i<6;i++) {
			for (int j = 0; j < 6; j++) {
				ans= ( ans+mPow_n_1[i][j] )%mod;
			}
		}
		System.out.println(ans*quick_Pow(4,n)%mod);
}
	//求i的n次方快速幂
	private static long quick_Pow(long i, int n) {
		long ret=1;
		while(n!=0) {
			if( (n&1)==1) {
				ret=(ret*i)%mod;
			}
			i=(i*i)%mod;
			n>>=1;
		}
		return ret;
	}
	
	/*
	 * 矩阵的快速幂
	 */
	private static long[][] mPow(long[][] conflict, int n) {
		long [][] ans=new long[6][6];
		
		//单位矩阵：对角线为1 其余皆为0
		for(int i=0;i<6;i++) {
			for(int j=0;j<6;j++) {
				if(i==j) {
					ans[i][j]=1;
				}else {
					ans[i][j]=0;
				}
				
			}
			
		}
		while(n!=0) {
			if((n&1)==1) {//该位上为1 ans矩阵与conflict矩阵相乘
				ans=mMul(ans,conflict);
			}
			conflict=mMul(conflict,conflict);
			//n右移一位 除以2
			n>>=1;
		}
		return ans;
		
	}
	//矩阵乘法
	private static long[][] mMul(long[][] a, long[][] b) {
		long [][] ans=new long[6][6];
		for(int i=0;i<6;i++) {
			for (int j = 0; j < 6; j++) {
				for (int k = 0; k < 6; k++) {
					ans[i][j]=( ans[i][j]+a[i][k]*b[k][j] )%mod;
				}
			}
		}
		return ans;
	}

}

矩阵幂运算解垒骰子

【思路】

f(i,j)表示第i个骰子，j朝上的所有集合
则f(i, j) = f(i - 1, k)之和，k从1到6

F(i) = F(i - 1) * A = F(1) * A^(n - 1)

在这里插入图片描述

import java.util.Scanner;
public class Main{
    static int n, m;
    static int mod = 1000000007;
    static int N = 6;
    static int a[][] = new int[N][N];
    static int f[][] = new int[N][N]; //f[i][j] 表示i骰子 j朝上的方案数
    
    public static int get_op(int x){
        if( x >= 3 )return x - 3;
        return x + 3;
    }
    
    public static void mul(int [][]c,  int [][] a, int [][] b){// C = A * B
        
        int t[][] = new int[N][N];
        for(int i = 0; i < N; i ++)
            for(int j = 0; j < N; j ++)
                for(int k = 0; k < N; k ++ )
                    t[i][j] =  (int)(t[i][j] +  (long) a[i][k] * b[k][j] )% mod;
        
        for(int i = 0; i < N; i ++)
            for(int j = 0; j < N; j++)
                c[i][j] = t[i][j];
        
    }
    public static void main(String args[]){
        
        Scanner reader = new Scanner(System.in);
        n = reader.nextInt();
        m = reader.nextInt();
        
        //初始化A矩阵
        for(int i = 0; i < N; i ++)
            for(int j = 0; j < N ;j ++)
                a[i][j] = 4;
        
        for(int i = 0; i < N; i ++)
            f[0][i] = 4;  
        
        while( m -- > 0){
            int x = reader.nextInt(), y = reader.nextInt();
            x --;
            y --;
            //剔除掉冲突的 构造冲突矩阵
            a[x][ get_op(y)] = 0;
            a[y][ get_op(x)] = 0;
        }
        
        
        //快速矩阵
        for(int i = n - 1; i > 0; i >>= 1 ){
            if( (i & 1) == 1) mul(f, f, a);  //F = F * A
            mul(a, a, a);  //A = A * A
        }
        int res = 0;
        for(int i = 0; i < N; i ++)
            res = (res + f[0][i]) % mod;
        System.out.println(res);
    }
}

关于矩阵的幂运算和乘法，参见我博客快速幂和矩阵乘法

生命之树

生命之树这道题是参考了南墙的代码的
我之前做这种图的都是将顶点邻接关系存储在邻接矩阵中的，
之前在蓝桥杯大臣的旅费这道题中有用过自定义图结构，这道题也类似。我对dfs并不陌生不过，倒是没有想到用回溯来统计每个结点的最大和谐值，通常是回溯后取消标记。


生命之树
在X森林里，上帝创建了生命之树。
他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，
代表这个点的和谐值。上帝要在这棵树内选出一个非空节点集S，
使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, ..., vk, b} 
使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。
在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。
这个最大的和就是上帝给生命之树的评分。
经过atm的努力，他已经知道了上帝给每棵树上每个节点上的整数。
但是由于 atm 不擅长计算，他不知道怎样有效的求评分。
他需要你为他写一个程序来计算一棵树的分数。

「输入格式」
第一行一个整数 n 表示这棵树有 n 个节点。
第二行 n 个整数，依次表示每个节点的评分。
接下来 n-1 行，每行 2 个整数 u, v，表示存在一条 u 到 v 的边。
由于这是一棵树，所以是不存在环的。

「输出格式」
输出一行一个数，表示上帝给这棵树的分数。

「样例输入」
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5

「样例输出」
8

「数据范围」
对于 30% 的数据，n <= 10
对于 100% 的数据，0 < n <= 10^5, 每个节点的评分的绝对值不超过 10^6 。

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 3000ms


package 第六届;

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class 生命树_网友版 {
	static int[] nodeValue;//存放各个点的和谐值
	static List<Integer>[] point;//存放各个点的包含的邻接边
	static int[] value;//存放以某个点为根节点情况下的最大和谐值和
	static int ans=0;//记录最大结果
	static void dfs(int son,int father) {
		value[son]=nodeValue[son];//以son为根节点，一开始时其最大和谐值为它本身
		for(int i=0;i<point[son].size();i++) {//枚举与son相连的结点
			int next=point[son].get(i);
			//当枚举的下一个结点是son先前经过的点father 跳过 防止绕圈
			if(next==father)continue;//如果都continue掉说明这个点是叶子结点
			dfs(next,son);
			//回溯（子节点平行状态都走完没得走了或者说状态没得转移了才会回溯）得到父节点与子节点和
			if(value[next]>0)//子节点的和谐值
				value[son]+=value[next];
			ans=Math.max(ans, value[son]);
		}
		
	}
	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		int n=reader.nextInt();
		nodeValue=new int [n+1];
		value=new int[n+1];
		point=new LinkedList[n+1];
		for(int i=1;i<=n;i++) {
			nodeValue[i]=reader.nextInt();
			point[i]=new LinkedList();
		}
		for(int i=1;i<n;i++) {
			int x=reader.nextInt();
			int y=reader.nextInt();
			point[x].add(y);
			point[y].add(x);
		}
		dfs(1,-1);//从0号结点开始搜索 假设它的父节点为-1可以为其他的无关量
		System.err.println(ans);
	}

}
JohnnyLin00
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2021年 第12届 蓝桥杯 第2次模拟赛真题详解及小结【Java版】
upward
01-13 8386
模拟赛网页截图 一、试题A——答案：168 二、试题B——答案：14 三、试题C——答案：2002 四、试题D——答案：65 解法一：找规律（累加求和） 五、试题E——答案：162 解法一：双重for循环遍历所有组合 六、试题F 解法一：整数相乘 七、试题G 解法一：整数运算 八、试题H 解法一：【求巨佬代码】 九、试题I 解法一：【求巨佬代码】 十、试题J 小结
蓝桥杯题目：立方变自身
菜鸟的升级之路
03-20 1906
立方变自身 观察下面的现象,某个数字的立方，按位累加仍然等于自身。 1^3 = 1  8^3  = 512    5+1+2=8 17^3 = 4913   4+9+1+3=17 ... 请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？ 请填写该数字，不要填写任何多余的内容或说明性的文字。 以下是我写的代码： packa
第六届Java软件开发B组
nanYangTangHeGuoTan的博客
05-23 879
1.标题：分机号 X老板脾气古怪，他们公司的电话分机号都是3位数，老板规定，所有号码必须是降序排列，且不能有重复的数位。比如： 751,520,321 都满足要求，而， 766,918,201 就不符合要求。 现在请你计算一下，按照这样的规定，一共有多少个可用的3位分机号码？ 请直接提交该数字，不要填写任何多余的内容。 答案：120种
第六届蓝桥杯 2015年省赛真题（Java 大学C组）
二两清酒.的博客
03-02 815
蓝桥杯---Java大学C组---个人赛日常刷题【day2】
蓝桥杯Java B组2015年真题
Magnolia_He的博客
03-23 273
由于时间有限，然后题目的难度并不是很大，基本上都是暴力枚举即可，所以在这里只列出部分代码以及题目~ 目录01三角形面积（结果填空3’）02立方变自身（结果填空5’）03三羊开泰（结果填空9’）04循环节长度（代码填空11’）05九数组分数（代码填空15’）06加法变乘法（结果填空17’）07牌型种数（结果填空21’）08饮料换购（程序设计13’）09垒骰子（程序设计25’）10生命之树（程序设计31’） 01三角形面积（结果填空3’） 02立方变自身（结果填空5’） 观察下面的现象,某个数字的立方，按位累加
【蓝桥杯】Java_B组2015年省赛真题
weixin_48434658的博客
03-12 759
Java_B组2015年省赛真题01 三角形面积02 立方变自身03 三羊献瑞04 循环节长度05 九数组分数06 加法变乘数07 牌型种数08 饮料换购09 垒骰子10 生命之树 01 三角形面积 如图1所示。图中的所有小方格面积都是1。 那么，图中的三角形面积应该是多少呢？ 请填写三角形的面积。不要填写任何多余内容或说明性文字。 答案：28   02 立方变自身 观察下面的现象,某个数字的立方，按位累加仍然等于自身。 1^3 = 1 8^3 = 512 5+1+2=8
第六届蓝桥杯 2015年国赛真题（Java 大学C组）
二两清酒.的博客
03-14 539
蓝桥杯---Java大学C组---个人赛日常刷题【day10】
第六届蓝桥杯真题java_[蓝桥杯][2015年第六届真题]机器人繁殖 （Java代码）
weixin_39628864的博客
02-25 105
解题思路:设开始有x个机器人，若第n年后，机器人数目为s，有方程ax-b=s，列举出前n项后找到a,b增加的规律：inta=1,b=0,d=1;for(i=0;id*=2;a+=d;b+=d-1;}再通过x=(s+b)/a可求出x的值；以上只是算法描述，当n取值为30，a的值就达到整型数的上限，n再增加，就会产生溢出，所以只能用大数进行加减乘除，大数加法用c语言实现并不难，但是要做乘除运算，实现...
Java实现蓝桥杯第十届2019年JavaB组真题
JohnnyLin
10-15 2215
不同子串 【问题描述】 一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分 注意子串和子序列的区别： 子串要求连续，子序列可以
2015年第六届蓝桥杯决赛 Java本科C组
04-15
个人整理的2015年第六届蓝桥杯决赛 Java本科C组试题，希望可以帮到大家。
蓝桥杯嵌入式2015年第六届省赛真题代码
01-31
在“蓝桥杯嵌入式2015年第六届省赛真题代码”中，我们可以看到参赛者们面对的挑战涉及到这一领域的多个关键知识点。 1. **处理器架构**：嵌入式系统的核心是处理器，常见的有ARM、MIPS、PowerPC等架构。2015年的...
【蓝桥杯单片机第九届国赛真题】
06-03
【蓝桥杯单片机第九届国赛真题】是一个针对单片机技术与编程的竞赛，旨在检验参赛者在单片机应用开发方面的能力。蓝桥杯是中国颇具影响力的IT技术竞赛之一，尤其在教育和考试领域有很高的认可度。单片机，又称微控制...
第十四届蓝桥杯 Java C组省赛真题
04-08
本资源为第十四届蓝桥杯 Java C 组省赛真题，涵盖了 Java 编程基础知识点，包括结果填空和程序设计两种题型。本总结将对题目中的知识点进行详细说明。 一、结果填空题 结果填空题要求选手根据题目描述直接填写结果...
蓝桥杯第十五届电子赛省赛单片机组真题压缩包
最新发布
04-13
【标题】"蓝桥杯第十五届电子赛省赛单片机组真题压缩包"所包含的知识点主要围绕单片机、蓝桥杯比赛以及相关的教育与考试领域展开。蓝桥杯是一项全国性的信息技术竞赛，旨在提升大学生和青少年在软件和电子信息领域的...
Java实现蓝桥杯第十一届2020年JavaB组真题
JohnnyLin
04-05 3119
【思路】 有四种走法，往下走四个格子，对角（左下和右下）走四个格子,往上走四个格子。 dfs将每种格子的可能走法枚举，同时统计能走出2020的路径的方案数 package 第十一届; import java.util.Scanner; /** * @author JohnnyLin * @version Creation Time：2021年4月1日 下午8:51:23 */ public class _B寻找2020 { static int N = 55; static char f[][]
Java实现蓝桥杯第十二届2021年JavaB组真题
JohnnyLin
05-09 2439
C 直线 【思路】 区域中的点两两组合，根据斜截式计算出每条直线的k和b。 难点在于对于 <k,b>怎么不重不漏地统计数量。 这里想到用 Map<Double, Set>，注意k、b可能为小数。相同的k映射到 同一个Set中，用Set判去重复的b。 package 第十二届; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; i
Java实现蓝桥杯 垒骰子
JohnnyLin
03-16 998
解法一、dfs暴力法 /*题目描述 垒骰子 赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭， 要垒成方柱体。经过长期观察，atm 发现了稳定骰子的奥秘；有些数字的面贴着 会互相排斥！ 我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。 假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同...
Java实现蓝桥杯第九届2018年真题
JohnnyLin
06-04 821
标题：第几天 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 31 29 31 30 4 125 标题：方格计数 如图p1.png所示，在二维平面上有无数个1x1的小方格。 我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。 你能计算出这个圆里有多少个完整的小方格吗？ 注意：需要提交的是一个整数，不要填写任何多余内容。 1 0 1 2 1 4-1 3 4 9-4 4 9 16-9= 5 4 1000 999
Java实现蓝桥杯历年真题全排列算法
"蓝桥杯Java历年真题及答案，涉及程序设计和算法设计，主要针对字符串的全排列问题" 在程序设计和算法设计领域，全排列是一个常见的问题，特别是在编程竞赛如“蓝桥杯”中。全排列是指给定一个序列，将其所有元素...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值