zoukankan      html  css  js  c++  java
  • 第八届蓝桥杯JavaA组省赛真题

    解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论

    题目1、迷宫

    题目描述
    X星球的一处迷宫游乐场建在某个小山坡上。
    它是由10x10相互连通的小房间组成的。

    房间的地板上写着一个很大的字母。
    我们假设玩家是面朝上坡的方向站立,则:
    L表示走到左边的房间,
    R表示走到右边的房间,
    U表示走到上坡方向的房间,
    D表示走到下坡方向的房间。

    X星球的居民有点懒,不愿意费力思考。
    他们更喜欢玩运气类的游戏。这个游戏也是如此!

    开始的时候,直升机把100名玩家放入一个个小房间内。
    玩家一定要按照地上的字母移动。

    迷宫地图如下:

    UDDLUULRUL
    UURLLLRRRU
    RRUURLDLRD
    RUDDDDUUUU
    URUDLLRRUU
    DURLRLDLRL
    ULLURLLRDU
    RDLULLRDDD
    UUDDUDUDLL
    ULRDLUURRR

    请你计算一下,最后,有多少玩家会走出迷宫?
    而不是在里边兜圈子。

    请提交该整数,表示走出迷宫的玩家数目,不要填写任何多余的内容。

    如果你还没明白游戏规则,可以参看一个简化的4x4迷宫的解说图:p1.png

    在这里插入图片描述

    public class Main
    {
        static char[][] a = new char[10][10];
        static boolean[][] b = new boolean[10][10];
        static int cnt = 0;
        public static void main(String[] args) {
            String str="UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR";  
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                    a[i][j] = str.charAt(i*10+j);
                }
            }
    
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                    int x = i;
                    int y = j;
                    init();
                    while (true) {
                        if (x < 0 || x > 9 || y < 0 || y > 9) {
                            cnt++;
                            break;
                        }
                        if  (b[x][y] == true) {
                            break;
                        }
                        b[x][y] = true;
                        switch (a[x][y]) {
                        case 'U':
                            x -= 1;
                            break;
                        case 'D':
                            x += 1;
                            break;
                        case 'L':
                            y -= 1;
                            break;
                        case 'R':
                            y += 1;
                            break;
                        default:
                            break;
                        }
                    }
                }
            }
            System.out.println(cnt);
        }
        private static void init() {
            // TODO Auto-generated method stub
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                    b[i][j] = false;
                }
            }
        }
    }
    
    题目2、9算数式

    题目描述
    观察如下的算式:

    9213 x 85674 = 789314562

    左边的乘数和被乘数正好用到了1~9的所有数字,每个1次。
    而乘积恰好也是用到了1~9的所有数字,并且每个1次。

    请你借助计算机的强大计算能力,找出满足如上要求的9数算式一共有多少个?

    注意:

    1. 总数目包含题目给出的那个示例。
    2. 乘数和被乘数交换后作为同一方案来看待。
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.text.ParseException;
    import java.util.Scanner;
    
    /**
     * 
     * @description TODO
     * @author frontier
     * @time 2019年3月23日 上午9:24:01
     *
     */
    public class 结果填空29算数式 {
    	static Scanner in = new Scanner(System.in);
    	static boolean[] vis = new boolean[10];
    	static int count;
    	static int a, b, result;
    
    	public static void main(String[] args) throws ParseException, FileNotFoundException {
    		Scanner in = new Scanner(new File("src/JavaA/s8/1.txt"));
    		dfs(0, "");
    		System.out.println(count / 2);
    
    	}
    
    	static boolean check(int num) {
    		String n = num + "";
    		boolean[] v = new boolean[10];
    		if (n.length() != 9)
    			return false;
    		for (int i = 0; i < 9; ++i) {
    			int cur = Integer.parseInt(n.charAt(i) + "");
    			if (cur < 1 || cur > 9)
    				return false;
    			if (!v[cur])
    				v[cur] = true;
    			else
    				return false;
    		}
    		return true;
    	}
    
    	static boolean check1(int resultNum) {
    		boolean isVisitedC[] = new boolean[10];
    		while (resultNum != 0) {
    			int numNow = resultNum % 10;
    			if (numNow < 1 && numNow > 9)
    				return false;
    			isVisitedC[numNow] = true;
    			resultNum /= 10;
    		}
    		for (int i = 1; i < 10; i++) {
    			if (isVisitedC[i] == false)
    				return false;
    		}
    		return true;
    	}
    
    	static void dfs(int n, String s) {
    		if (n == 9) {
    			for (int i = 1; i <= 8; ++i) {
    				a = Integer.parseInt(s.substring(0, i));
    				b = Integer.parseInt(s.substring(i));
    				result = a * b;
    				if (check(result))
    					count++;
    			}
    			return;
    		}
    
    		for (int i = 1; i <= 9; ++i) {
    			if (!vis[i]) {
    				vis[i] = true;
    				dfs(n + 1, s + i);
    				vis[i] = false;
    			}
    		}
    	}
    }
    
    
    题目3、魔方状态

    题目描述
    二阶魔方就是只有2层的魔方,只由8个小块组成。
    如图p1.png所示。

    小明很淘气,他只喜欢3种颜色,所有把家里的二阶魔方重新涂了颜色,如下:

    前面:橙色
    右面:绿色
    上面:黄色
    左面:绿色
    下面:橙色
    后面:黄色

    请你计算一下,这样的魔方被打乱后,一共有多少种不同的状态。

    如果两个状态经过魔方的整体旋转后,各个面的颜色都一致,则认为是同一状态。

    请提交表示状态数的整数,不要填写任何多余内容或说明文字。

    在这里插入图片描述

    开始拿到这道题没什么思路,笔算算不来,模拟判重感觉太麻烦。大神说burnside引理可以做,学渣表示看不懂。。网上基本没有求解的,有的也答案不一。最后还是模拟判重这么写了。

    我的答案:229878

    测试:全同色魔方状态为1,正确。正常二阶魔方状态3674160,正确。

    思路:其实就是空间状态搜索。模拟操作+判重。关于操作,二阶魔方只做U(顶层顺时针) R(右层顺时针) F(前层顺时针)就可以得到所有状态了。判重需要旋转整个魔方去比较。(判重小白现在只会用set)。

    然后是,怎么去表示一个二阶魔方。二阶魔方8个块,一个块6面(看不见的作黑色考虑),所以我用了char st[8][7]去表示一个魔方。块的顺序如下:

    在这里插入图片描述

    上面的初始状态表示就是{{“oybbgb”},{“oygbbb”},{“bygbby”},{“bybbgy”},{“obbogb”},{“obgobb”},{“bbgoby”},{“bbbogy”}}

    o表示橙色,b表示黑色,g表示绿色,y表示黄色。

    对于一个小块,6个面的颜色定义顺序如下:

    在这里插入图片描述

    所以,比如说,上面题目给的魔方,前面一层,左上角的橙黄绿块,表示就是oybbgb

    博主还是个小白,只能找来C++的代码,还望 Java大佬及时写出

    #include <bits/stdc++.h>
    using namespace std;
    typedef char st[8][7];
    st state[2000000];
    set<string> all;
    st begin={{"oybbgb"},{"oygbbb"},{"bygbby"},{"bybbgy"},{"obbogb"},{"obgobb"},{"bbgoby"},{"bbbogy"}}; 
    //st begin={{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"}};
    //只有一个颜色的魔方 ans=1 
    //st begin={{"rykkbk"},{"rygkkk"},{"kygkko"},{"kykkbo"},{"rkkwbk"},{"rkgwkk"},{"kkgwko"},{"kkkwbo"}};
    //正常2阶魔方状态  r红 y黄 b蓝 g绿 w白 o橙  k黑(红对橙,白对黄,蓝对绿,颜色相近的相对)这里白为底 前为红
    //需要将state大小改为4000000
    //这个测试用例跑了20分钟左右 560M内存  ans=3674160 与实际二阶魔方状态数相同 见下截图 
    int front, tail;
    void ucell(char *a){swap(a[0], a[2]); swap(a[2], a[5]); swap(a[5], a[4]);}
    void rcell(char *a){swap(a[1], a[0]); swap(a[0], a[3]); swap(a[3], a[5]);}
    void fcell(char *a){swap(a[2], a[1]); swap(a[1], a[4]); swap(a[4], a[3]);}
    void u(st &s)//顶层顺时针旋转 
    {
    	ucell(s[0]);
    	ucell(s[1]);
    	ucell(s[2]);
    	ucell(s[3]);
    	swap(s[1], s[0]);
    	swap(s[2], s[1]);
    	swap(s[3], s[2]);
    }
    void uwhole(st &s)//整个魔方从顶部看 顺时针转 用于判重 
    {
    	u(s);
    	ucell(s[4]);
    	ucell(s[5]);
    	ucell(s[6]);
    	ucell(s[7]);
    	swap(s[5], s[4]);
    	swap(s[6], s[5]);
    	swap(s[7], s[6]);
    }
    void f(st &s)//前面一层 顺时针转 
    {
    	fcell(s[0]);
    	fcell(s[1]);
    	fcell(s[4]);
    	fcell(s[5]);
    	swap(s[1], s[5]);
    	swap(s[0], s[1]);
    	swap(s[4], s[0]);
    }
    void fwhole(st &s)//整个魔方从前面看 顺时针转 用于判重 
    {
    	f(s);
    	fcell(s[2]);
    	fcell(s[6]);
    	fcell(s[7]);
    	fcell(s[3]);
    	swap(s[2], s[6]);
    	swap(s[3], s[2]);
    	swap(s[7], s[3]);
    }
    void r(st &s)//魔方右层顺时针转 
    {
    	rcell(s[1]);
    	rcell(s[2]);
    	rcell(s[6]);
    	rcell(s[5]);
    	swap(s[2], s[1]);
    	swap(s[5], s[1]);
    	swap(s[6], s[5]);
    }
    void rwhole(st &s)//整个魔方从右边看 顺时针转 用于判重 
    {
    	r(s);
    	rcell(s[0]);
    	rcell(s[3]);
    	rcell(s[4]);
    	rcell(s[7]);
    	swap(s[3], s[7]);
    	swap(s[0], s[3]);
    	swap(s[4], s[0]);
    }
    string convert(st &s)//魔方状态二维字符数组 转化为string 
    {
    	string ss;
    	for(int i=0; i<8; i++)ss+=s[i];
    	return ss;
    }
    bool try_to_insert(int tail)//判重 
    {
    	st k;
    	memcpy((void*)k, (void*)state[tail], sizeof(state[tail]));
    	for(int i=0; i<4; i++)
    	{
    		fwhole(k);
    		for(int j=0; j<4; j++)
    		{
    			uwhole(k);
    			for(int q=0; q<4; q++)
    			{
    				rwhole(k);
    				if(all.count(convert(k))==1)
    				{
    					return false;
    				}
    			}
    		}
    	}
    	all.insert(convert(k));
    	return true;
    }
    int main()
    {
    	front=0,tail=1;
    	all.insert(convert(begin));
    	memcpy((void*)state[0],(void*)begin,sizeof(begin));
    	while(front!=tail)
    	{
    		//对当前状态分别模拟三种操作U R F 然后判重 
    		for(int i=0; i<3; i++)
    		{
    			memcpy((void*)state[tail], (void*)state[front], sizeof(state[front]));
    			if(i==0)
    			{
    				u(state[tail]);
    				if(try_to_insert(tail))tail++;
    			}
    			else if(i==1)
    			{
    				r(state[tail]);
    				if(try_to_insert(tail))tail++;
    			}
    			else if(i==2)
    			{
    				f(state[tail]);
    				if(try_to_insert(tail))tail++;
    			}
    		}
    		front++;
    	}
    	cout<<front<<endl;
    	return 0;
    }
    //ans 229878
    
    题目4、方格分割

    题目描述
    6x6的方格,沿着格子的边线剪开成两部分。
    要求这两部分的形状完全相同。

    如图:p1.png, p2.png, p3.png 就是可行的分割法。

    试计算:
    包括这3种分法在内,一共有多少种不同的分割方法。
    注意:旋转对称的属于同一种分割法。

    请提交该整数,不要填写任何多余的内容或说明文字。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    PS:
    包括这3种分法在内,一共有多少种不同的分割方法。
    注意:旋转对称的属于同一种分割法。
    请提交该整数,不要填写任何多余的内容或说明文字。

    解析:从中心N/2开始进行深搜,需要定义方向数组dir[][]和记录数组vis[][]

    public class Main
    {
    	static int[][] a = new int[6][6];
    	static boolean[][] vis = new boolean[10][10];
    	static int[][] dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    	static int cnt = 0;
    	public static void main(String[] args) {
    		vis[3][3] = true;
    		f(3, 3);
    		System.out.println(cnt/4);
    	}
    	private static void f(int x, int y) {
    		// TODO Auto-generated method stub
    		if (x == 0 || x == 6 || y == 0 || y == 6) {
    			cnt++;
    			return;
    		}
    		for (int i = 0; i < 4; i++) {
    			int dx = x + dir[i][0];
    			int dy = y + dir[i][1];
    			if (vis[dx][dy] == false) {
    				vis[dx][dy] = true;
    				vis[6-dx][6-dy] = true;
    				f(dx, dy);
    				vis[6-dx][6-dy] = false;
    				vis[dx][dy] = false;
    			}
    			
    		}
    	}
    }
    
    
    题目5、字母组串

    由 A,B,C 这3个字母就可以组成许多串。
    比如:“A”,“AB”,“ABC”,“ABA”,“AACBB” …
    现在,小明正在思考一个问题:
    如果每个字母的个数有限定,能组成多少个已知长度的串呢?
    他请好朋友来帮忙,很快得到了代码,
    解决方案超级简单,然而最重要的部分却语焉不详。
    请仔细分析源码,填写划线部分缺少的内容。

    public class A
    {
    	// a个A,b个B,c个C 字母,能组成多少个不同的长度为n的串。
    	static int f(int a, int b, int c, int n)
    	{
    		if(a<0 || b<0 || c<0) return 0;
    		if(n==0) return 1; 
    		
    		return ________________________________;  //填空
    	}
    	
    	public static void main(String[] args)
    	{
    		System.out.println(f(1,1,1,2));
    		System.out.println(f(1,2,3,3));
    	}
    }
    

    对于上面的测试数据,小明口算的结果应该是:
    6
    19
    算法内部用列举法把所有排列情况都列举一遍,

    每一个递归填写a或b或c三个字母

    答案为:f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1)
    
    题目6、最大公共子串

    最大公共子串长度问题就是:
    求两个串的所有子串中能够匹配上的最大长度是多少。

    比如:“abcdkkk” 和 “baabcdadabc”,
    可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

    下面的程序是采用矩阵法进行求解的,这对串的规模不大的情况还是比较有效的解法。

    请分析该解法的思路,并补全划线部分缺失的代码。

    这个有点dp的意思,分别计算两个字符串每一个字符到另一个字符是否相等 若相等 则加前面字符的最大字符串 若前面字符也分别相等则他就等于a[i-1][j-1]+1 若不想等则为0+1

    public class 最大公共子串 {
    	static int f(String s1, String s2)  
        {  
            char[] c1 = s1.toCharArray();  
            char[] c2 = s2.toCharArray();  
      
            int[][] a = new int[c1.length+1][c2.length+1];  
      
            int max = 0;  
            for(int i=1; i<a.length; i++){  
                for(int j=1; j<a[i].length; j++){  
                    if(c1[i-1]==c2[j-1]) {  
                        a[i][j]=a[i-1][j-1]+1;  //填空  
                        if(a[i][j] > max) max = a[i][j];  
                    }  
                }  
            }  
      
            return max;  
        }  
      
        public static void main(String[] args){  
            int n = f("abcdkkk", "baabcdadabc");  
            System.out.println(n);  
        }
    }
    
    题目7、正则问题

    考虑一种简单的正则表达式:
    只由 x ( ) | 组成的正则表达式。
    小明想求出这个正则表达式能接受的最长字符串的长度。

    例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是: xxxxxx,长度是6。

    输入

    一个由x()|组成的正则表达式。输入长度不超过100,保证合法。

    输出

    这个正则表达式能接受的最长字符串的长度。

    例如,
    输入:
    ((xx|xxx)x|(x|xx))xx

    程序应该输出:
    6

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.text.ParseException;
    import java.util.Scanner;
    
    /**
     
     * 采用DFS,从前到后遍历遇到(就开始新的搜索,遇到)则停止搜索并通过比较,找出这个括号里的最大值;
     * 如果遇到|,则需要记录之前的长度,用于在之后)的比较。遇到x,长度加一,且继续往下找
     * 
      每一个()都是一次dfs,可返回期间最大x数量
     */
    public class 编程7正则问题 {
    	// static Scanner in = new Scanner(System.in);
    	static int count;
    	static char[] a = new char[200];
    	static int p;
    
    	public static void main(String[] args) throws ParseException, FileNotFoundException {
    		Scanner in = new Scanner(new File("src/JavaA/s8/7.txt"));
    		a = in.next().toCharArray();
    		System.out.println(dfs());
    	}
    
    	static int dfs() {
    		int xnum = 0;
    		int maxx = 0;
    
    		while (p < a.length) {
    			if (a[p] == 'x') {
    				p++;
    				xnum++;
    			} else if (a[p] == '(') {
    				p++;
    				xnum += dfs();
    			} else if (a[p] == ')') {
    				p++;
    				break;
    			} else if (a[p] == '|') {
    				p++;
    				maxx=xnum;
    				//maxx = Math.max(xnum, maxx);
    				xnum = 0;
    			}
    		}
    		return Math.max(xnum, maxx);
    	}
    }
    
    
    题目8、包子凑数

    题目描述
    小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼,其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼,可以认为是无限笼。

    每当有顾客想买X个包子,卖包子的大叔就会迅速选出若干笼包子来,使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼,分别能放3、4和5个包子。当顾客想买11个包子时,大叔就会选2笼3个的再加1笼5个的(也可能选出1笼3个的再加2笼4个的)。

    当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼,分别能放4、5和6个包子。而顾客想买7个包子时,大叔就凑不出来了。

    小明想知道一共有多少种数目是包子大叔凑不出来的。

    输入

    第一行包含一个整数N。(1 <= N <= 100)
    以下N行每行包含一个整数Ai。(1 <= Ai <= 100)

    输出

    一个整数代表答案。如果凑不出的数目有无限多个,输出INF。

    例如,
    输入:
    2
    4
    5

    程序应该输出:
    6

    再例如,
    输入:
    2
    4
    6

    程序应该输出:
    INF

    样例解释:
    对于样例1,凑不出的数目包括:1, 2, 3, 6, 7, 11。
    对于样例2,所有奇数都凑不出来,所以有无限多个。

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。
    提交程序时,注意选择所期望的语言类型和编译器类型。

    package com.sihai.test;
    
    import java.util.Scanner;
    
    public class test {
        static int dp[] = new int[10000];  
        public static boolean judge(int x,int y)  
        {  
            int t;  
            while(y>0)  
            {  
                t=x%y;  
                x=y;  
                y=t;  
            }  
            if(x==1)  
                return true;  
            return false;  
        } 
    
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int a[] = new int[200];
            int n = 0,i,j,res,mark;  
            n = scanner.nextInt();
            while(true)  
            {  
                res=0;  
                mark=0;  
                for(i=1;i<=n;i++)  
                {  
                    a[i] = scanner.nextInt();  
                }  
                for(i=1;i<=n;i++)  
                {  
                    for(j=1;j<=n;j++)  
                    {  
                        if(judge(a[i],a[j]))  
                        {  
                            mark=1;  
                            break;  
                        }  
                    }  
                    if(mark==1)  
                        break;  
                }  
                if(mark!=1)  
                {  
                    System.out.println("INF");  
                    continue;  
                }  
                dp[0]=1;  
                for(i=1;i<=n;i++)  
                    for(j=1;j<10000;j++)  
                    {  
                        if(a[i]>j)  
                            continue;  
                        if(dp[j-a[i]]==1)  
                            dp[j]=1;  
                    }  
                for(i=0;i<10000;i++)  
                {  
                    if(dp[i]!=1)  
                        res++;  
                }  
                System.out.println(res);  
            }  
        }
    }
    
    
    题目9、分巧克力

    题目描述
    儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
    小明一共有N块巧克力,其中第i块是Hi x Wi的方格组成的长方形。

    为了公平起见,小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足:
    1. 形状是正方形,边长是整数
    2. 大小相同

    例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。

    当然小朋友们都希望得到的巧克力尽可能大,你能帮小Hi计算出最大的边长是多少么?

    输入
    第一行包含两个整数N和K。(1 <= N, K <= 100000)
    以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
    输入保证每位小朋友至少能获得一块1x1的巧克力。

    输出
    输出切出的正方形巧克力最大可能的边长。

    样例输入:
    2 10
    6 5
    5 6

    样例输出:
    2

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。

    import java.util.Scanner;
    class Cho {
        int h;
        int w;
        public Cho(int h, int w) {
            // TODO Auto-generated constructor stub
            this.h = h;
            this.w = w;
        }
    }
    public class Main2 {
        static int n, k;
        static Cho[] cho;
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            n = in.nextInt();
            k = in.nextInt();
            int low = 1;
            int mid = 0;
            int high = 100000;
            cho = new Cho[n];
            for (int i = 0; i < n; i++) {
                int a = in.nextInt();
                int b = in.nextInt();
                cho[i] = new Cho(a, b);
            }
    //      二分,基本思路为暴力,从大到小能够保证最先出来的结果就是符合要求的最大情况
            while (low < high -1) {
                mid = (low + high) /2;
                if (!judge(mid)) {
                    high = mid;
                } else {
                    low = mid;
                }
            }
            System.out.println(mid - 1);
    
        }
        private static boolean judge(int l) {
            // TODO Auto-generated method stub
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += (cho[i].h * cho[i].w) / (l * l);
                if (sum >= k) {
                    return true;
                }
            }
            return false;
        }
    } 
    
    题目10、油漆问题

    题目描述
    X星球的一批考古机器人正在一片废墟上考古。
    该区域的地面坚硬如石、平整如镜。
    管理人员为方便,建立了标准的直角坐标系。

    每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
    经过各种测量,每个机器人都会报告一个或多个矩形区域,作为优先考古的区域。

    矩形的表示格式为(x1,y1,x2,y2),代表矩形的两个对角点坐标。

    为了醒目,总部要求对所有机器人选中的矩形区域涂黄色油漆。
    小明并不需要当油漆工,只是他需要计算一下,一共要耗费多少油漆。

    其实这也不难,只要算出所有矩形覆盖的区域一共有多大面积就可以了。
    注意,各个矩形间可能重叠。

    本题的输入为若干矩形,要求输出其覆盖的总面积。

    输入格式:
    第一行,一个整数n,表示有多少个矩形(1<=n<10000)
    接下来的n行,每行有4个整数x1 y1 x2 y2,空格分开,表示矩形的两个对角顶点坐标。
    (0<= x1,y1,x2,y2 <=10000)

    输出格式:
    一行一个整数,表示矩形覆盖的总面积。

    例如,
    输入:
    3
    1 5 10 10
    3 1 20 20
    2 7 15 17

    程序应该输出:
    340

    再例如,
    输入:
    3
    5 2 10 6
    2 7 12 10
    8 1 15 15

    程序应该输出:
    128

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 2000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。

    import java.util.Scanner;
    
    
    public class youqiwenti3 {
    	 static int n, sum = 0;
    	    static int[][] p = new int[1000][10000];
    	    public static void main(String[] args) {
    	        Scanner in = new Scanner(System.in);
    	        n = in.nextInt();
    	        for (int i = 0; i < n; i++) {
    	            int x1 = in.nextInt();
    	            int y1 = in.nextInt();
    	            int x2 = in.nextInt();
    	            int y2 = in.nextInt();
    	            paint(x1, y1, x2, y2);
    	        }
    	        for (int i = 0; i < p.length; i++) {
    	            for (int j = 0; j < p[i].length; j++) {
    	                sum += p[i][j];
    	            }
    	        }
    	        System.out.println(sum);
    	    }
    	    private static void paint(int x1, int y1, int x2, int y2) {
    	        // TODO Auto-generated method stub
    	        for (int i = x1; i < x2; i++) {
    	            for (int j = y1; j < y2; j++) {
    	                p[i][j] = 1;
    	            }
    	        }
    	    }
    
    }
    
    
    
  • 相关阅读:
    POJ 3669 Meteor Shower【BFS】
    用于JS日期格式化,以及简单运算的Date包装工具类
    asp+jQuery解决中文乱码
    jQuery制作信息提示弹出层插件【推荐】
    让 SyntaxHighlighter 3.x 支持 Lua 语法着色
    JQuery操作TABLE,及console.info问题。
    可加装广告的swf播放器JS代码
    Java 绘制环形的文字 (Circle Text Demo)
    Java数据库操作类演示
    Java 通过 HTTP 下载文件
  • 原文地址:https://www.cnblogs.com/a1439775520/p/12948142.html
Copyright © 2011-2022 走看看