第二届蓝桥杯C++B组国(决)赛真题

以下代码仅供参考,解答部分来自网友,对于正确性不能保证,如有错误欢迎评论

四方定理.
数论中有著名的四方定理:所有自然数至多只要用四个数的平方和就可以表示。
我们可以通过计算机验证其在有限范围的正确性。

对于大数,简单的循环嵌套是不适宜的。下面的代码给出了一种分解方案。

请仔细阅读,填写空缺的代码(下划线部分)。

注意:请把填空的答案(仅填空处的答案,不包括题面)存入考生文件夹下对应题号的“解答.txt”中即可。
直接写在题面中不能得分。

int f(int n, int a[], int idx)
{
    if(______________) return 1;  // 填空1
    if(idx==4)  return 0;

    for(int i=(int)sqrt(n); i>=1; i--)
    {
        a[idx] = i;

        if(_______________________)  return 1;  // 填空2
    }

    return 0;
}

int main(int argc, char* argv[])
{
    for(;;)
    {
        int number;
        printf("输入整数(1~10亿):");
        scanf("%d",&number);
        
        int a[] = {0,0,0,0};

        int r = f(number, a, 0);

        printf("%d: %d %d %d %d\n", r, a[0], a[1], a[2], a[3]);
        
    }

    return 0;
}



a[0]*a[0] + a[1]*a[1] + a[2]*a[2] + a[3]*a[3] == n
f(n, a, idx + 1) == 1
来自网友:

本题满分: 9分
 
  填空1: (3分)
  n==0
  或者:0==n
 
  填空2: (6分)
  f(n-i*i, a, idx+1)
  或者:
  f(n-i*i, a, idx+1) > 0
  f(n-i*i, a, idx+1) == 1

异或加密法.
在对文本进行简单加密的时候,可以选择用一个n位的二进制数,对原文进行异或运算。
解密的方法就是再执行一次同样的操作。

加密过程中n位二进制数会循环使用。并且其长度也可能不是8的整数倍。

下面的代码演示了如何实现该功能。
请仔细阅读,填写空缺的代码(下划线部分)。

void f(char* buf, unsigned char* uckey, int n)
{

    int i;
    for(i=0; i> (i%8)
uckey[i/8] &= ~((unsigned char)0x80 >> (i%8))

本题满分:14分
  
  填空1:(7分)
  uckey[i/8] |= (unsigned char)0x80 >> (i%8);    //>>表示右移位,位逻辑运算符:&按位与,|按位或,^按位异或,~取反,移位运算符:<<左移,>>右移
从数学上看,左移1位等于乘以2,右移1位等于除以2,然后再取整,移位溢出的丢弃
 
  填空2:(7分)
  uckey[i/8] &= ~((unsigned char)0x80 >> (i%8));
 
  注意所有逻辑等价形式都是正确的答案,比如可以使用左移位:
  (unsigned char)0x80 >> 2  等价于:0x01 << 5

最小公倍数、
为什么1小时有60分钟,而不是100分钟呢?这是历史上的习惯导致。
但也并非纯粹的偶然:60是个优秀的数字,它的因子比较多。
事实上,它是1至6的每个数字的倍数。即1,2,3,4,5,6都是可以除尽60。

我们希望寻找到能除尽1至n的的每个数字的最小整数。

不要小看这个数字,它可能十分大,比如n=100, 则该数为:
69720375229712477164533808935312303556800

请编写程序,实现对用户输入的 n (n<100)求出1~n的最小公倍数。

例如:
用户输入:
6
程序输出:
60

用户输入:
10
程序输出:
2520

要求考生把所有函数写在一个文件中。调试好后,存入与考生文件夹下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。
对于编程题目,要求选手给出的解答完全符合ANSI C标准,不能使用c++特性;
不能使用诸如绘图、中断调用等硬件相关或操作系统相关的API。

Java解法:

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    
    public void getResult(int n) {
        BigInteger temp1 = BigInteger.ONE;
        BigInteger temp2 = BigInteger.ONE;
        BigInteger temp3 = BigInteger.ONE;
        for(int i = 2;i <= n;i++) {
            temp1 = temp3;
            temp2 = new BigInteger(""+i);
            temp3 = temp1.gcd(temp2);
            temp3 = temp1.multiply(temp2).divide(temp3);
        }
        System.out.println(temp3);
    }
    
    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        test.getResult(n);
    }
}

C++解法:

解答:
最小公倍数就是所有质数的相应幂的积
比如N=10
小于10的质数有2,3,5,7
对应的最大幂是:3,2,1,1
则最小公倍数是:2^3x3^2x5^1x7^1 = 2520

 #include 
 #include 
 #include 
 using namespace std;
 
 int a[50] = {0};//存素数 
 bool vis[100];
 int b[50] = {0};//存幂次 
 
 void init_prim()//求小于100的所有素数存入数组a 
 {
      int i,j,k;
      int m = (int)(sqrt(100.0)+0.5);
      memset(vis,0,sizeof(vis));
      vis[0] = 1;
      vis[1] = 1;//必须加上,否则第一个素数别认为是1 
      for(i=2; i<=m; i++)
      if(!vis[i])
      {
           for(j=2*i; j<=100; j+=i)
                vis[j] = 1;
      }
      int t = 0;
      for(k=0; k<100; k++)
      if(!vis[k])
           a[t++] = k;
 }
      
 int main()
 {
      int i,j,k;
      init_prim();
      int n;
      //2^6 = 64,2^7 = 128;由于n最大100,幂次最大6 
     // for(i=0 ; i<100; i++)//素数没问题 
     // if(!vis[i])
     //      cout<>n)
      {
           memset(b,0,sizeof(b));
           for(i=0; i<=n&&a[i]<=n; i++)//”1到n素数个数小于n的一半 “不对,3有两个素数 
           {
               // cout<(double)n)
                     {
                          b[i] = j -1;//b的下标不必新开  
                          break;
                     }
                     else if(pow((double)a[i],(double)j) == (double)n)//必须分开 
                     {
                           b[i] = j;
                          break;     
                     }
                }                                   
           }
           //不知道是不是pow函数的问题,把ans定义为int得出的结果出问题,double就对了 
           double ans = 1;
           for(k=0; k
 #include 
 #include 
 #include 
 using namespace std;
 
 const int N = 105;
 int n;
 int a[N][50];
 int b[N] = {0};
 
 void multiply()
 {
     int i,j,k;
     memset(a,0,sizeof(a));
     for(i=3; i<=100; i++)
     {
         /*
         下面的是直接按平常的乘法,乘数的一位乘以被乘数的每一位并处理进位;另外是乘数整体乘以被乘数的每一位最后统一处理进位
         */
         int temp = 0; 
         a[i][0] = 1;//很重要 
         for(j=2; j<=i; j++)
         {
             int  c = 0; 
             for(k=0; k<50; k++)//最大不超过160位 ,目前是100!,最后除以3等50 
             {
                 temp = a[i][k]*b[j] + c;
                 a[i][k] = temp%1000;
                 c = temp/1000;
             }          
         }
     }
 }
 
 void printData(int n)
 {
     int i,j,k;
     for(i=49; i>=0; i--)
     if(a[n][i])
         break;
     cout<=0; j--)
         printf("%03d",a[n][j]);
     cout<>n)
     {
         
         if(n==1||n==2)
         {
             cout<

地铁换乘、

为解决交通难题,某城市修建了若干条交错的地铁线路,线路名及其所属站名如stations.txt所示。

线1
苹果园
....
四惠东

线2
西直门
车公庄
....
建国门

线4
....

其中第一行数据为地铁线名,接下来是该线的站名。
当遇到空行时,本线路站名结束。

下一行开始又是一条新线....直到数据结束。


如果多条线拥有同一个站名,表明:这些线间可以在该站换车。

为引导旅客合理利用线路资源,解决交通瓶颈问题,该城市制定了票价策略:

1. 每条线路可以单独购票,票价不等。
2. 允许购买某些两条可换乘的线路的联票。联票价格低于分别购票。

单线票价和联合票价如 price.txt 所示。

线1 180
.....
线13 114
线1,线2 350
线1,线10 390
.....


每行数据表示一种票价
线名与票价间用空格分开。如果是联票,线名间用逗号分开。
联票只能包含两条可换乘的线路。

现在的问题是:根据这些已知的数据,计算从A站到B站最小花费和可行的换乘方案。

比如,对于本题目给出的示例数据

如果用户输入:
五棵松,奥体中心

程序应该输出:
-(线1,线10)-线8 = 565

如果用户输入:
五棵松,霍营

程序应该输出:
-线1-(线4,线13) = 440

可以看出,用户输入的数据是:起始站,终到站,用逗号分开。
程序输出了购票方案,在括号中的表示联票,短横线(-)用来分开乘车次序。
等号后输出的是该方案的花费数值。


请编程解决上述问题。
注意:
1. 我们测试您的程序时,所用数据与题目中的示例数据不同,但格式完全一样。
2. 当多个方案有相同的最小花费,输出任意一个方案即可。


要求考生把所有类写在一个文件中。
调试好后,存入与考生文件夹下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。请不要使用package语句。

Java解法

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class js_04 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		String input=null;
		String[] tmp=null;
		while(scanner.hasNextLine()){
			input=scanner.nextLine();
			tmp=input.split(",");
			new js_04(tmp[0],tmp[1]);
		}
	}
	public js_04(String start,String end){
		//解析stations.txt文件,初始化站点信息
		initStations();
		//初始化线路相连信息
		initLines();
		//解析price.txt文件,初始化价格信息
		initPrice();
		input(start,end);
		startProcess();
	}
	//起始站集合
	private List start=new ArrayList();
	//终点站集合
	private List end=new ArrayList();
	//输入起始站和终点站
	public void input(String stationA,String stationB){
		//找到该站属于哪条线
		Iterator it=stationsMap.keySet().iterator();
		String stations=null;
		String line=null;
		while(it.hasNext()){
			line=it.next();
			stations=stationsMap.get(line);
			if(stations.contains(stationA+",")){
				//添加到开始线路集合
				start.add(line);
			}
			if(stations.contains(stationB+",")){
				//添加到结束线路集合
				end.add(line);
			}
		}
	}
	//开始正式处理
	public void startProcess(){
		for(String st:start){
			for(String en:end){
				Line cuStart=lines.get(st);
				cuStart.isUse=true;
				process.add(cuStart);
				nfs(cuStart,lines.get(en));
				process.remove(cuStart);
				cuStart.isUse=false;
			}
		}
		//输入最终结果
		if(minPriceProcess!=null){
			System.out.print(minPriceProcess+" = ");
			System.out.println(minPrice);
		}else{
			System.out.println("不可达");
		}
	}
	//存储遍历过程
	private List process=new ArrayList(); 
	public void nfs(Line startLine,Line endLine){
		//结束找到符合要求的路径
		if(startLine.equals(endLine)){
			calPrice();
		}else{
			//遍历所有的可连接节点
			for(Line line:startLine.connLines){
				//已经遍历过则跳过
				if(line.isUse)continue;
				line.isUse=true;
				process.add(line);
				nfs(line,endLine);
				process.remove(line);
				line.isUse=false;
			}
		}
	}
	//存储最少价钱
	private int minPrice=Integer.MAX_VALUE;
	private void calPrice(){
		length=process.size();
		String calProcss="";//存储过程
		cal(0,0,calProcss);
	}
	private int length;
	private String minPriceProcess;
	//lineIndex表示当前要处理的路线的下标
	public void cal(int lineIndex,int currPrice,String calProcess){
		if(lineIndex>=length){
			if(currPrice=minPrice)return;
			cal(lineIndex+1,currPrice+one.price,calProcess+"-"+one);
			int connPrice=isConnection(one,two);
			if(connPrice!=-1){//可以相连,则考虑相连的情况
				if(currPrice+connPrice>=minPrice)return;
				cal(lineIndex+2,currPrice+connPrice,calProcess+"-("+one.name+","+two.name+")");
			}
		}
	}
	//判断两条线路是否联票,是则返回联票价钱,否则返回-1
	public int isConnection(Line one,Line two){
		String key=one.name+","+two.name;
		Integer value=connLines.get(key);
		if(value==null)return -1;
		return value;
	}
	//用于保存所有的线路信息,key为线路名,value为该线路下的所有站点
	private Map stationsMap=new HashMap();
	//存储线路的集合,通过路线名获得路线类对象
	private Map lines=new HashMap();
	public void initStations(){
		try {
			File file=new File("stations.txt");
			BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream(file)));
			StringBuilder value=new StringBuilder();
			String content=null;
			String key=null;
			boolean isHead=true;//是否是线路名
			while((content=reader.readLine())!=null){
				if("".equals(content)){//一条线路读取结束
					//将线路存储起来
					Line line=new Line();
					line.name=key;
					lines.put(key, line);
					stationsMap.put(key, value.toString());
					isHead=true;
					value.delete(0, value.length());
				}else{
					if(isHead){//第一个为线路名
						key=content;
						isHead=false;
					}else{
						value.append(content).append(",");
					}
				}
			}
			Line line=new Line();
			line.name=key;
			lines.put(key, line);
			stationsMap.put(key, value.toString());
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	//初始化线路连接情况
	public void initLines(){
		List list=new ArrayList(stationsMap.keySet());
		int length=list.size();
		for(int i=0;i connLines=new HashMap();
	//初始化价钱列表,获得联票信息
	public void initPrice(){
		try {
			File file=new File("price.txt");
			BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream(file)));
			String content=null;
			String[] keyValue=null;
			int price=0;
			while((content=reader.readLine())!=null){
				keyValue=content.split(" ");
				price=Integer.valueOf(keyValue[1]);
				if(keyValue[0].contains(",")){//联票
					connLines.put(keyValue[0], price);
				}else{//单条路线
					lines.get(keyValue[0]).price=price;
				}
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//自定义线路类
	class Line{
		//线路名
		public String name;
		//是否遍历过
		public boolean isUse;
		//和该路线交叉的路线
		List connLines=new ArrayList();
		//该路线的价钱
		public int price;
		@Override
		public boolean equals(Object obj) {
			return this.name.equals(((Line)obj).name);
		}
		@Override
		public String toString() {
			return this.name;
		}
	}
}

C++:

#include
using namespace std;
#define LEN 50
typedef struct stations{
    char name[20];
    int len;
    int roads[50];
    struct stations *left;
    struct stations *right;
}Stations;

typedef struct etree{
    int value;
    int roadNum;
    struct etree *father;
    int childnum;
}ETree;

typedef struct queue{
    ETree *tie;
    struct queue *next;
}Queue;

void pushQueue(Queue &head, ETree *&etree){
    Queue *p=head.next,*q=&head;
    while(p!=NULL &&  (p->tie->valuevalue)){
        q=p;
        p=p->next;
    }
    q->next=(Queue*)malloc(sizeof(Queue));
    q->next->tie=etree;
    q->next->next=p;
}
void freeEtree(ETree *q){
    ETree *p;
    while(q->childnum==0){
        p=q;
        q=q->father;
        free(p);
        if(q!=NULL)
            q->childnum--;
        else
            break;
    }
}

void freeAll(Stations *&head){
    if (head!=NULL){
        freeAll(head->left);
        freeAll(head->right);
        free(head);
    }
}

void showBest(ETree *h,int price[][LEN],char roadName[][20],int roadNum){
    if(h!=NULL){
        if (h->faher==NULL){
            printf("%s",roadName[h->roadNum]);
        }
        else{
            int j;
            j=h->roadNum;
            if (h->value==(price[j][j]+h->father->value)){
                showBest(h->father,price,roadName,roadNum);
                if (price[j][roadNum]){
                    printf("-(%s,%s)",roadName[j],roadName[price[j][roadNum]-1]);

                }
                else
                    printf("-%s",roadName[j]);
            }
            else{
                showBest(h->father->father,price,roadNme,roadNum);
                printf("-(%s,%s)",roadName[h->father->roadNum],roadName[j]);
            }
        }
    }
}

inline int compares(char s1[],int n1,chr s2[],int n2){
    if (n1!=n2)
        return n1-n2;
    return strcmp(s1,s2);
}
boll findStation(Stations* &head,Stations* &p,char s[]){
    int len=strlen(s);
    int t;
    Stations q;
    p=head;
    while (n!=NULL){
        q=p;
        t=compares(s,len,p->name,p->len);
        if (t<0)
            p=p->left;
        else
            retrn true;
    }
    p=q;
    return false;
}

void insert(Stations* &head,char s[],int road,int price[][LEN]{
    Stations *p,*q;
    int t;
    t=strlen(s);
    if(s[t-1]=='\n')
        s[t-1]='\0';
    if(head==NULL){
        p=(Stations *)malloc(sizeof(Stations));
        p->left=NULL;
        p->rght=NULL;
        strcpy(p->name,s);
        p->len=strlen(s);
        p->road[0]=1;
        p->road[1]read;
        head=p;
    }
    else{
        if (findStation(head,p,s)){
            p->roads[0]++;
            t=p->roads[0];
            p->roads[t]=road;
            for(t--;t>0,t--){
                price[p->road[t]][road]=-1;
                price[road][p->road[t]]=-1;
            }
        }
        else{
            q=p;
            p=(Stations *)malloc(sizeof(Stations));
            p->left=NULL;
            p->right=NULL;
            strcpy(p->name,s);
            p->len=strlen(s);
            p->road[0]=1;
            p->road[1]=road;
            t=compares(s,p->len,q->name,q->len);
            if(t<0)
                q->left=p;
            else
                q->right=p;
        }
    }
}

int GetRoadNum(char *r,char roadName[][20],int road Num){
    for (int i=0;ik){
            price[i][roadNum]=j+1;
        }
        if (price[j][j]>k){
            price[j][j]=k;
            price[j]roadNum]=i+1;
        }
    }
    else{
        i=GetRoadNum(line,roadName,roadNum);
        price[i][i]=k;
    }
}

fclose(fp);

char starts[20]={"五棵松"},ends[20]="奥体中心"};
Stations *sroad,*eroad;
Queue Qhead, *h;
Etree *p,*q;
while(true){
    char Flag[LEN]={0};//为-1表示目标,为0表示尚未发生过扩展
    Qhead.next=NULL;
    Qhead.tie=NULL;
    scanf("%[^,\n]s",starts);
    if (getchar()!=',')
        break;
    scanf("%[^\n]s",ends);
    getchar();
    if (!findStation(head,sroad,starts)){
        printf("未找到%s的匹配项\n",starts);
        continue;
    }
    if (!findStation(head,eroad,ends)){
        printf("未找到%s的匹配项\n",ends);
        continue;
    }
    for (i=1;i<=sroad->roads[0];i++){
        p=(ETree*)malloc(sizeof(ETree));
        p->father=NULL;
        p->childnum=0;
        p->roadNum=sroad->roads[i];
        p->value=price[p->roadum][p->roadNum];
        pushQueue(Qhead,p);
    }
    for (i=1;i<=eroad->roads[0];i++){
        Flag[eroad->roads[i]]=-1;
    }
    while(Qhead.next!=NULL){
        h=Qhead.next;
        q=h->tie;
        if (Flag[q->roadNum]==-1){
            break;
        }
        Qhuad.next=Qhead.next->next;
        i=q->roadNum;
        if (Flag[i]!=1){
            for(j=0;jchildnum++;
                    p=(ETree*)malloc(sizeof(ETree));
                    p->father=q;
                    p->childnum=0;
                    p->roadNum=j;
                    k=price[j][j]>0){
                        if(price[i][j]>0){
                            if(q->father!=NULL)
                                t=price[i][j]+q->father->value;
                            else
                                t=price[i][j];
                            if (k>t)
                                k=t;
                        }
                        p->value=k;
                        pushQueue(Qhead,p);
                    }
                }
                Flag[i]=1;
            }
            freeETree(h->tie);
            free(h);
        }
        if (Qhead.next!=NULL){
            showBest(q,price,roadName,roadNum);
            printf("=%d\n",q->value);
        }
        else
            printf("此路不通\n");
        for(;Qhead.next!=NULL;){
            h=Qead.next;
            Qhead.nexQhead.next->next;
            freeETree(h->tie);
            free(h);
        }
    }
    freeAll(head);
}

连通问题、
BMP是常见的图像存储格式。
如果用来存黑白图像(颜色深度=1),则其信息比较容易读取。

与之相关的数据:

(以下偏移均是从文件头开始)
偏移:10字节, 长度4字节: 图像数据真正开始的位置。
偏移:18字节, 长度4字节: 位图的宽度,单位是像素。
偏移:22字节, 长度4字节: 位图的高度,单位是像素。

从图像数据开始处,每个像素用1个二进制位表示。
从图片的底行开始,一行一行向上存储。

Windows规定图像文件中一个扫描行所占的字节数必须是4字节的倍数,
不足的位均以 0 填充。例如,图片宽度为45像素,实际上每行会占用
8个字节。

可以通过Windows自带的画图工具生成和编辑二进制图像。
需要在“属性”中选择“黑白”,指定为二值图像。
可能需要通过 查看 | 缩放 | 自定义… 把图像变大比例一些,
更易于操作。

图像的左下角为图像数据的开始位置。白色对应1,黑色对应0

我们可以定义:两个点距离如果小于2个像素,则认为这两个点连通。
也就是说:以一个点为中心的九宫格中,围绕它的8个点与它都是连通的。
如:t1.bmp 所示,左下角的点组成一个连通的群体;
而右上角的点都是孤立的。

        in.bmp                                t1.bmp

程序的目标是:根据给定的黑白位图,分析出所有独立连通的群体,
输出每个连通群体的面积。所谓面积,就是它含有的像素的个数。

输入数据固定存在in.bmp中。

如示例的in.bmp,
程序应该输出:
81
133

该输出表示:共有4个连通群体。
输出的连通体面积间的顺序可以随意。

请编程解决上述问题。

我们测试程序的时候,会使用不同的in.bmp文件。

要求考生把所有类写在一个文件中。
调试好后,存入与考生文件夹下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。请不要使用package语句。

第二届蓝桥杯C++B组国(决)赛真题_第1张图片
第二届蓝桥杯C++B组国(决)赛真题_第2张图片

这题要读入图片文件数据,感觉头大啊,此前做的题,几乎没有遇到要读取文件中的数据,而现在竟然还碰到了读取图片的数据,看到此题的核心:即使用DFS求取连通图的问题,并且返回每一个连通图中包含的顶点个数,但是对于此题处理读取数据的问题,就没有仔细去探究,下面贴出一段网友的C语言代码,以作参考:

include 
#include 
#include 
#include 

void main(){ 
int i,j,k,m; 
int width,height,start,world; 
int *bmp,*Lcount; 
bool *Lflag; 
FILE *fp; 
if((fp=fopen("in1.bmp","rb"))==NULL){ 
printf("文件打开失败"); 
return; 
}
fseek(fp,10L,0); 
fscanf(fp,"%4c",&start); // 4c表示该数据占4个字节
// printf("start = %d\n",start); 
fseek(fp,18,0); 
fscanf(fp,"%4c",&width); 
// printf("width = %d\n",width); 
fseek(fp,22,0); 
fscanf(fp,"%4c",&height); 
// printf("height = %d\n",height); 
bmp = (int*)malloc((width+2)*sizeof(int)); 
memset(bmp,0,(width+2)*sizeof(int)); 
Lcount = (int*)malloc(width*sizeof(int)); 
memset(Lcount,0,width*sizeof(int)); 
Lflag = (bool*)malloc(width*sizeof(bool)); 
memset(Lflag,0,width*sizeof(bool)); 
Lcount--; 
Lflag--; 
fseek(fp,start,0); 
world = ( width%32 ? width/32+1 : width/32 )*4; 
int last,i1,i2,i3; 
int eCount = 0 
for(i=0 i= 0 && k<=width m-- ){ 
if( !( 1<

你可能感兴趣的:(#,蓝桥杯历届真题,蓝桥杯历届真题,Java,C++B组,国赛,第二届蓝桥杯,蓝桥杯)