精华内容
下载资源
问答
  • 编程题#1: 画家问题 来源: POJ(Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。) 注意: 总时间限制: 1000ms 内存限制: 65536kB 描述 有一个正方形的墙,由N*N个正方形的砖组成,其中一些砖是...

    编程题#1: 画家问题

    来源: POJ (Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。)

    注意: 总时间限制: 1000ms 内存限制: 65536kB

    描述

    有一个正方形的墙,由N*N个正方形的砖组成,其中一些砖是白色的,另外一些砖是黄色的。Bob是个画家,想把全部的砖都涂成黄色。但他的画笔不好使。当他用画笔涂画第(i, j)个位置的砖时, 位置(i-1, j)、 (i+1, j)、 (i, j-1)、 (i, j+1)上的砖都会改变颜色。请你帮助Bob计算出最少需要涂画多少块砖,才能使所有砖的颜色都变成黄色。

     

    输入

    第一行是个整数t(1≤t ≤20),表示要测试的案例数。然后是t个案例。每个案例的首行是一个整数n (1≤n ≤15),表示墙的大小。接下来的n行表示墙的初始状态。每一行包含n个字符。第i行的第j个字符表示位于位置(i,j)上的砖的颜色。“w”表示白砖,“y”表示黄砖。

     

    输出

    每个案例输出一行。如果Bob能够将所有的砖都涂成黄色,则输出最少需要涂画的砖数,否则输出“inf”。

     

    样例输入

    2
    3
    yyy
    yyy
    yyy
    5
    wwwww
    wwwww
    wwwww
    wwwww
    wwwww

     

    样例输出

    0
    15 

      1 #include <iostream>
      2 #include <math.h>
      3 using namespace std;
      4 int guess(int *puzzle, int *press,int i)
      5 {
      6     int c, r, count = 0;
      7     for (c = 1; c < i+1; ++c) {
      8         if (press[(i+2)+c] == 1) count++;
      9     }
     10     for (r=1; r< i; r++) {
     11         for (c = 1; c < i+1; ++c) {
     12             // 跟踪puzzle第一行,计算press其他行的值
     13             press[(r + 1)* (i+2) +c] = (puzzle[r*(i+2)+c] + press[r*(i+2)+c] + press[(r - 1)*(i+2)+c]
     14                                     + press[r*(i+2)+c - 1] + press[r*(i+2)+c + 1]) % 2;
     15             if (press[(r + 1)* (i+2) +c] == 1) count++;
     16         }
     17     }
     18     for (c=1; c < i + 1; c++) {
     19         if ((press[i*(i+2)+c - 1] + press[i*(i+2)+c] + press[i*(i+2)+c + 1] +
     20                 press[(i - 1)*(i+2)+c]) % 2 != puzzle[i*(i + 2)+c]) {
     21             return -1; // 返回-1标示该press的第一行不能使地板全变黄
     22         }
     23 
     24     }
     25     return count;//如果能使地板全变黄,返回该办法所需涂的地砖的个数
     26 }
     27 
     28 int enumerate (int *puzzle, int *press,int i)
     29 {
     30     int c, sum = -1,n= (int)pow(2,i);
     31     for ( c=1; c<i+1; c++) {
     32         press[(i+2)+c] = 0;
     33     }
     34     if (guess(puzzle, press, i) != -1) {
     35         sum = guess(puzzle, press, i);
     36     }
     37     while (n--) {
     38         press[(i+2)+1]++;
     39         c = 1;
     40         while (press[(i+2)+c] > 1) {
     41             press[(i+2)+c] = 0;
     42             c++;
     43             press[(i+2)+c]++;
     44         }
     45         if (guess(puzzle, press, i) != -1) {
     46             if (sum == -1) {
     47                 sum = guess(puzzle, press, i);
     48             } else if (guess(puzzle, press, i) < sum) {
     49                 sum = guess(puzzle, press, i);
     50             }
     51         }
     52     }
     53     return sum;
     54 }
     55 
     56 int main()
     57 {
     58     int cases,i;
     59     cin>>cases;
     60     while (cases--) {
     61         cin>>i;
     62         if (i == 1) {
     63             char t;
     64             cin >> t;
     65             if (t == 'w') {
     66                 cout<<1<<endl;
     67             } else {
     68                 cout<<0<<endl;
     69             }
     70         } else {
     71             int *puzzle, *press;
     72             puzzle = new int[(i+2)*(i+2)];//初始数组
     73             press = new  int[(i+2)*(i+2)];//按下状态,按下为1,未操作为0
     74             //初始化press数组
     75             int c, r;
     76             for (r=0; r<i+1; r++) {
     77                 press[r*(i+2)] = press[r*(i+2)+i+1] = 0;
     78             }
     79             for (c=1; c<i+1; c++) {
     80                 press[c] = 0;
     81             }
     82             //输入数据
     83             for(r=1; r<i+1; r++) {
     84                 for(c=1; c<i+1; c++) {
     85                     char t;
     86                     cin >> t;
     87                     if (t == 'w') {
     88                         puzzle[r*(i+2)+c] = 1;
     89                     } else {
     90                         puzzle[r*(i+2)+c] = 0;
     91                     }
     92                 }
     93             }
     94             int result = enumerate(puzzle,press,i);
     95             if (result == -1) {
     96                 cout<<"inf"<<endl;
     97             } else {
     98                 cout<<result<<endl;
     99             }
    100         }
    101 
    102     }
    103 
    104     return 0;
    105 }

     

    转载于:https://www.cnblogs.com/dagon/p/4814296.html

    展开全文
  • 编程题#1: 画家问题 来源: POJ (http://bailian.openjudge.cn/practice/2813/) 注意: 总时间限制: 1000ms 内存限制: 65536kB 描述 有一个正方形的墙,由N*N个正方形的砖组成,其中一些砖是白色的,另外一些砖...

    编程题#1: 画家问题

    来源: POJ (http://bailian.openjudge.cn/practice/2813/)

    注意: 总时间限制: 1000ms 内存限制: 65536kB

    描述
    有一个正方形的墙,由N*N个正方形的砖组成,其中一些砖是白色的,另外一些砖是黄色的。Bob是个画家,想把全部的砖都涂成黄色。但他的画笔不好使。当他用画笔涂画第(i, j)个位置的砖时, 位置(i-1, j)、 (i+1, j)、 (i, j-1)、 (i, j+1)上的砖都会改变颜色。请你帮助Bob计算出最少需要涂画多少块砖,才能使所有砖的颜色都变成黄色。
    这里写图片描述

    输入
    第一行是个整数t(1≤t ≤20),表示要测试的案例数。然后是t个案例。每个案例的首行是一个整数n (1≤n ≤15),表示墙的大小。接下来的n行表示墙的初始状态。每一行包含n个字符。第i行的第j个字符表示位于位置(i,j)上的砖的颜色。“w”表示白砖,“y”表示黄砖。

    输出
    每个案例输出一行。如果Bob能够将所有的砖都涂成黄色,则输出最少需要涂画的砖数,否则输出“inf”。

    样例输入

    2
    3
    yyy
    yyy
    yyy
    5
    wwwww
    wwwww
    wwwww
    wwwww
    wwwww

    样例输出

    0
    15 


    程序解答:

    #include <iostream>
    using namespace std;
    
    int getPaintNum(int paint[][17]){    //获得每次成功的喷涂数
        int num = 0;
        for (int i = 0; i < 16; i++){
            for (int j = 0; j < 17; j++)
                num += paint[i][j];
        }
    
        return num;
    }
    
    bool guessNum(int wall[][17], int paint[][17], int n){    //判断喷涂是否成功
        int c, r;
    
        //根据画板颜色和周围paint颜色值判断下一行paint的颜色值
        for (r = 1; r<n; r++)
            for (c = 1; c <= n; c++)
                paint[r + 1][c] = (wall[r][c] + paint[r][c] + paint[r - 1][c] + paint[r][c - 1] + paint[r][c + 1]) % 2;
    
        //判断最后一行能否被画成黄色   
        for (c = 1; c <= n; c++)
            if ((paint[n][c - 1] + paint[n][c] + paint[n][c + 1] + paint[n-1][c]) % 2 != wall[n][c])
                return(false);
    
        return(true);
    }
    
    
    void theLeastPaints(int wall[][17], int paint[][17], int n){    //输出最少喷涂数
        int leastNum = 16 * 17;  //最少喷涂砖块数
    
        int c, cTemp = 0;
        while (1){
            if (guessNum(wall, paint, n) == true){
                if (leastNum > getPaintNum(paint))
                    leastNum = getPaintNum(paint);
            }
    
            //枚举第一行的所有情况,枚举方法:用二进制依次加1的进位方法模拟实现
            paint[1][1]++;
            c = 1;
            while (paint[1][c] > 1) {
                paint[1][c] = 0;
    
                c++; 
                if (c > cTemp)
                    cTemp = c;
    
                paint[1][c]++;
            }
            if (cTemp > n)
                break;
        }
    
        if (leastNum == 16 * 17)
            cout << "inf" << endl;
        else
            cout << leastNum;
    }
    
    int main(){
        int wall[16][17];    //墙的颜色矩阵,行数15+1,列数15+2;1表示白色,0表示黄色,都先置0
        int paint[16][17];   //涂画矩阵,行数15+1,列数15+2;0表示不涂画,1表示涂画,都先置0
    
        int t;
        int n;  //墙的大小
        char c; //墙的颜色
        cin >> t;
        while (t--){
            //矩阵初始化为 0,要专门初始化!!!
            for (int i = 0; i < 16; i++){
                for (int j = 0; j < 17; j++){
                    wall[i][j] = 0;
                    paint[i][j] = 0;
                }
            }
    
            cin >> n;
            for (int i = 1; i < n+1; i++){
                for (int j = 1; j < n+1; j++){
                    cin >> c;
                    if (c == 'w')
                        wall[i][j] = 1;
                }
            }
    
            theLeastPaints(wall, paint, n);
        }
    
        return 0;
    }

    附:
    听课思路总结参考
    枚举的应用:熄灯问题&讨厌的青蛙:http://blog.csdn.net/qq_30258957/article/details/54884977

    展开全文
  • 编程题#2:拨钟问题 来源: POJ (Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。) 注意: 总时间限制: 1000ms 内存限制: 65536kB 描述 有9个时钟,排成一个3*3的矩阵。  (图 1) 现在需要...

    编程题#2:拨钟问题

    来源: POJ (Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。)

    注意: 总时间限制: 1000ms 内存限制: 65536kB

    描述
    有9个时钟,排成一个3*3的矩阵。
    这里写图片描述
               (图 1)
    现在需要用最少的移动,将9个时钟的指针都拨到12点的位置。共允许有9种不同的移动。如下表所示,每个移动会将若干个时钟的指针沿顺时针方向拨动90度。

    移动 影响的时钟
    1 ABDE
    2 ABC
    3 BCEF
    4 ADG
    5 BDEFH
    6 CFI
    7 DEGH
    8 GHI
    9 EFHI
    (图 2)

    输入
    从标准输入设备读入9个整数,表示各时钟指针的起始位置。0=12点、1=3点、2=6点、3=9点。

    输出
    输出一个最短的移动序列,使得9个时钟的指针都指向12点。按照移动的序号大小,输出结果。

    样例输入

    3 3 0
    2 2 2
    2 1 2

    样例输出

    4 5 8 9 



    程序解答(此程序有缺陷,每个移动不能重复使用):

    #include <iostream>
    #include <set>
    #include <vector>
    #include <iterator> 
    using namespace std;
    
    bool guessOperation(const int clocks[], const int rotate[][9], const int signs[]){
        int clocksTemp[9];
        memcpy(clocksTemp, clocks, sizeof(clocksTemp));  //要拷贝一份,不能直接修改 clocks 数组!
        // memcpy(dest, source, sizeof dest); http://zh.cppreference.com/w/cpp/string/byte/memcpy
    
        int n = 0;  //表示第 n 个钟,从0到8
        while (n < 9){
            for (int i = 0; i < 9; i++)
                clocksTemp[n] += rotate[i][n] * signs[i];
    
            if (clocksTemp[n] % 4 != 0)
                return false;
    
            n++;
        }
        return true;
    }
    
    //函数对象,比较移动序列的长短
    class MyCompare{
    public:
        bool operator()(const vector<int>& operation1, const vector<int>& operation2){
            return (operation1.size() < operation1.size());
        }
    };
    
    int main(){
        int clocks[9];
        int signs[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };  //标记要使用的操作,0代表不使用,1代表使用
        set<vector<int>, MyCompare> operations;
        set<vector<int>, MyCompare>::iterator ioperation;
        vector<int> operation;
        //vector<int>::iterator ii;
    
        //根据读入数据初始化时钟旋转的次数,时钟旋转的次数应为4的整数倍!
        int n;
        for (int i = 0; i < 9; i++){
            cin >> n;
            switch (n){
            case 0: clocks[i] = 0; break; //犯了一个超低级的错误!这里要加 break; !!!
            case 1: clocks[i] = 1; break; //犯了一个超低级的错误!这里要加 break; !!!
            case 2: clocks[i] = 2; break; //犯了一个超低级的错误!这里要加 break; !!!
            case 3: clocks[i] = 3; break; //犯了一个超低级的错误!这里要加 break; !!!
            }
        }
    
        const int rotate[9][9] =
        {
        //钟 A  B  C  D  E  F  G  H  I
            {1, 1, 0, 1, 1, 0, 0, 0, 0 },  //op1: ABDE
            {1, 1, 1, 0, 0, 0, 0, 0, 0 },  //op2: ABC
            {0, 1, 1, 0, 1, 1, 0, 0, 0 },  //op3: BCEF
            {1, 0, 0, 1, 0, 0, 1, 0, 0 },  //op4: ADG
            {0, 1, 0, 1, 1, 1, 0, 1, 0 },  //op5: BDEFH
            {0, 0, 1, 0, 0, 1, 0, 0, 1 },  //op6: CFI
            {0, 0, 0, 1, 1, 0, 1, 1, 0 },  //op7: DEGH
            {0, 0, 0, 0, 0, 0, 1, 1, 1 },  //op8: GHI
            {0, 0, 0, 0, 1, 1, 0, 1, 1 }   //op9: EFHI
        };
    
        /*以下书写太麻烦!
        int rotate[9][9]; 
        //拨钟矩阵初始化
        for (int i = 0; i < 3; i++){
            for (int j = 0; j < 3; j++)
                rotate[i][j] = 0;
        }
        //操作1——9初始化
        rotate[0][0]++; rotate[0][1]++; rotate[0][3]++; rotate[0][4]++;  
        rotate[1][0]++; rotate[1][1]++; rotate[1][2]++;
        rotate[2][1]++; rotate[2][2]++; rotate[2][4]++; rotate[2][5]++;
        ...
        */
    
        int c, cTemp = 0;
        while (1){
            if (guessOperation(clocks, rotate, signs) == true){  //判断拨钟是否成功
                for (int i = 0; i < 9; i++){    //记录此时的操作序列
                    if (signs[i] == 1)
                        operation.push_back(i + 1);
                }
                operations.insert(operation);   //用 set 容器储存所有的成功操作序列,并且自动按移动序列的长短排序
                operation.clear();    //清空当前的成功操作序列
            }
    
            //按rotate的列枚举所有情况 
            c = 0;
            signs[0]++;
            while (signs[c] > 1) {
                signs[c] = 0;
                c++;
                if (c > 8)
                    break;
                signs[c]++;
            }
            if (c > 8)
                break;
        }
    
        if (operations.size() > 0){
            ioperation = operations.begin();
            ostream_iterator<int> o(cout, " ");  //放到输出流的时候,每放一个整数,就末尾添加一个" "中的内容 http://blog.csdn.net/u012482828/article/details/72549003
    
            copy((*ioperation).begin(), (*ioperation).end(), o);  //V中的数据通过流迭代器o放到o输出流中
            //参考:
            // http://blog.csdn.net/happyygdx/article/details/78535968
            // http://blog.csdn.net/happyygdx/article/details/78534884
    
            cout << endl;
        }
        else{
            cout << "无有效的移动序列!" << endl;
        }
    
        return 0;
    }



    其他正确解法参考:
    http://www.cnblogs.com/CCBB/archive/2011/09/13/2175043.html

    展开全文
  • 编程题#1: 画家问题 来源: POJ (Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。) 注意: 总时间限制: 1000ms 内存限制: 65536kB 描述 有一个正方形的墙,由N*N个正方形的砖组成,...

    编程题#1: 画家问题

    来源: POJ (Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。)

    注意: 总时间限制: 1000ms 内存限制: 65536kB

    描述

    有一个正方形的墙,由N*N个正方形的砖组成,其中一些砖是白色的,另外一些砖是黄色的。Bob是个画家,想把全部的砖都涂成黄色。但他的画笔不好使。当他用画笔涂画第(i, j)个位置的砖时, 位置(i-1, j)、 (i+1, j)、 (i, j-1)、 (i, j+1)上的砖都会改变颜色。请你帮助Bob计算出最少需要涂画多少块砖,才能使所有砖的颜色都变成黄色。

     

    输入

    第一行是个整数t(1≤t ≤20),表示要测试的案例数。然后是t个案例。每个案例的首行是一个整数n (1≤n ≤15),表示墙的大小。接下来的n行表示墙的初始状态。每一行包含n个字符。第i行的第j个字符表示位于位置(i,j)上的砖的颜色。“w”表示白砖,“y”表示黄砖。

     

    输出

    每个案例输出一行。如果Bob能够将所有的砖都涂成黄色,则输出最少需要涂画的砖数,否则输出“inf”。

     

    样例输入

    2
    3
    yyy
    yyy
    yyy
    5
    wwwww
    wwwww
    wwwww
    wwwww
    wwwww

     

    样例输出

    0
    15 
    
    
    #include <iostream>
    #include <cstring>
    
    using namespace std;
    
    bool IsTheSolution(int wall[17][17], int (*press)[17][17], int n)
    {
    	//重置press函数除第一行外的其他部分
    	for (int i = 2; i <= n; ++i) {
    		for (int j = 0; j <= n; ++j) {
    			(*press)[i][j] = 0;
    		}
    	}
    	
    	//枚举在第一行确定后的n-1行,推算出最后一行是否符合要求
    	for (int i = 2; i <= n; i++)
    	{
    		//枚举每一行的具体情况
    		for (int j = 1; j <= n; j++)
    		{
    			int temp = (wall[i - 1][j] + (*press)[i - 1][j] + (*press)[i - 1][j + 1] + (*press)[i - 1][j - 1] + (*press)[i - 2][j])%2;
    			if (temp == 1) //说明墙已经是黄色的了
    			{
    				(*press)[i][j] = 0;
    			}
    			else if (temp == 0) //墙是白色的,还是要涂一下
    			{
    				(*press)[i][j] = 1;
    			}
    		}
    	}
    
    	//判断最后一行的情况,来返回对错0.
    	for (int i = 1; i <= n; i++)
    	{
    		if ((wall[n][i]+(*press)[n][i-1]+ (*press)[n][i+1]+ (*press)[n-1][i]+ (*press)[n][i])%2==0)
    		{
    			return false;
    		}
    	}
    	return true;
    }
    
    int GetStep(int press[17][17], int n)
    {
    	int count = 0;
    	for (int i = 1; i <= n; i++) {
    		for (int j = 1; j <= n; j++) {
    			if (press[i][j] == 1)
    				count += 1;
    		}
    	}
    	return count;
    }
    
    bool IsFinished(int press[17][17], int n)
    {
    	for (int i = 1; i <= n; i++)
    	{
    		if (press[1][i] != 1) {
    			//cout << "当前枚举尚未完成" << endl;
    			return false;
    		}
    	}
    	//cout << "当前枚举已经完成" << endl;
    	return true;
    }
    
    //void PrintPress(int Press[][17], int n)
    //{
    //	for(int i = 1; i <= n; i++)
    //	{
    //		cout << endl;
    //		for(int j = 1; j <= n; j++)
    //		{
    //			cout << Press[i][j] << " ";
    //		}
    //	}
    //}
    
    int main()
    {
    	int t;
    	cin >> t;
    	for (int i = 0; i < t; ++i)
    	{
    		int n;
    		cin >> n;
    		int wall[17][17]; //最外层包含一层0围墙,因此行和列都要加2行
    		int press[17][17];
    		for (int i = 0; i < 17; i++)
    		{
    			for (int j = 0; j < 17; j++)
    			{
    				wall[i][j] = 0;
    				press[i][j] = 0;
    			}
    		}
    
    		//输入数据并将数据转化成0和1,0表示白色,1表示黄色
    		for (int j = 1; j <= n; j++)
    		{
    			for (int k = 1; k <= n; k++)
    			{
    				char temp;
    				cin >> temp;
    				if (temp == 'y')
    					wall[j][k] = 1;
    				else if (temp == 'w')
    					wall[j][k] = 0;
    			}
    		}
    
    		int minstep = 1000000;
    		bool lineOneComplete = false;
    		while (lineOneComplete == false)
    		{
    			int step = 0;
    			//利用二进制枚举
    			for (int i = 1; i <= n; i++)
    			{
    				if (press[1][i] > 1)
    				{
    					press[1][i] = 0;
    					press[1][i + 1] += 1;
    				}
    			}
    
    
    			//判断是否是合理的解,是否需要更新最小步数
    			if (IsTheSolution(wall, &press, n) == true)
    			{
    				step = GetStep(press, n);
    				//cout << "成功枚举的步数是: " << step << endl;
    				if (step < minstep)
    				{
    					minstep = step;
    				}
    			}
    			else {
    			}
    
    			//判断是否枚举完毕
    			lineOneComplete = IsFinished(press, n);
    			press[1][1]++;
    		}
    
    		if (minstep == 1000000) {
    			cout << "inf" << endl;
    		}
    		else {
    			cout << minstep << endl;
    		}
    	}
    	return 0;
    }
    


    展开全文
  • 编程题枚举变量作为循环控制变量#include<stdio.h>void main(){ enum season {spring=1,summer,autumn,winter}s;for(s=spring;s<=winter;s++) printf("%d\n",s);} 转载于:...
  •  定义枚举类型money,用枚举元素代表包括1 角、5角、1 元、5 元、10 元、50 元、100元,以元为单位输入一个数值,试将数值划分成合理的各种面值组合。为了计算方便,可先将各种钱币面值用枚举量为下标的数组存储。 ...
  • 编程题:为枚举类型变量赋值。将整型值强制类型转换成枚举类型赋值#include<stdio.h>void main(){ enum season {spring,summer,autumn,winter}s1,s2; s1=summer; s2=(enum season)2; printf("s1=%d,s2=%d\n",...
  • 如果我们用枚举的方法,枚举出每一行的翻法,复杂度为 O ( 2 M N ) O(2^{MN}) 。 但是我们发现,只要枚举出第一行的所有翻法,那么第二行的翻法是确定的(就是保证第一行的中所有是黑色的格子,则必须翻转对应的...
  • #include<stdio.h>void main(){ enum season {spring=1,summer,autumn,winter}s; for(s=spring;s<=winter;s++) printf("%d\n",s);} 转载于:https://blog.51cto.com/c10086/1413760...
  • 前言在平时的算法的题目中,时常会遇到组合数相关的问题,暴力枚举。在N个数中挑选M个数出来。利用for循环也可以处理,但是可拓展性不强,于是写这个模板供以后参考。两个函数和全局变量可以直接用。代码:#include#...
  • 时间限制:3秒 ...由于每个数的范围很小,我们可以枚举每一个数字,假设它是所在区间中的最小数,然后看它最左最右的范围。 预处理一下区间和,然后搞一下区间范围,然后枚举答案。。。 */
  • Python编程习题

    2020-12-22 10:59:07
    警察局抓了a,b,c,d四名偷窃嫌疑犯,其中只有一人是小偷。审问中 a说:“我不是小偷。” b说:“c是小偷。” c说:“小偷肯定是d。” d说:“c在冤枉人。” 现在已经知道四个人中三人说的是真话...注意:在x的枚举过程
  • 首先突破口肯定在这个6上,纸的数量不多,再通过仔细观察后发现,纸摆放的位置只有9种情况,那现在思路已经很明确了:1、输进去数据2、一一枚举每张纸的每一个位置的情况3、回溯查找4、格式输出,收工。不多说,直接...
  • 力扣编程题

    2021-01-27 20:30:22
    枚举数组中的每一个数 x,寻找数组中是否存在 target - x。 2.数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。 可以生成所有 2^{2n}2 2n 个 ‘(’ 和 ‘)’ 字符构成的...
  • PTA编程题部分补题

    2020-02-29 17:20:46
    这个并不难,但是它是真的体现出了算法的魅力,这有很多的解法,最容易想到的就是暴力枚举所有可能性,把所有的子列都算出来再找最大值,但是这样做的时间复杂度达到了O(ne3);还有一种较好的方法就是分而治之...
  • 编程题实战

    2018-09-06 16:55:25
    有一串玛瑙项链,项链上面有N个玛瑙珠子,这些玛瑙有M (M &lt; = 9) 种不同的颜色,购买的时候可以只选择购买项链长度为K(K&lt;=n)的一段。...枚举每一个买项链的位置,然后模拟一遍统计有多...
  • 面试编程题

    2017-11-21 11:18:02
    给定一个集合,枚举它所有可能的子集。 比如给定集合{1,2,3},应该输出: {} {1} {2} {1, 2} {3} {1, 3} {2, 3} {1, 2, 3} 1.2 增量构造法 增量构造法,每次选择一个元素放到...
  • 编程算法之枚举

    2015-04-11 22:41:47
    枚举法是编程里常用的算法之一,依赖于计算机的强大计算能力来穷尽没一种可能的情况,从而达到解决问题的目的,改算法效率并不高,但适用于一些没有明显规律可循的环境。 在小学奥数中经常会看到一些填数字的...
  • java之编程题

    2020-05-28 21:40:41
    使用枚举,遍历ArrayList类 import java.util.ArrayList; import java.util.Enumeration; import java.util.Vector; public class Demo { public static void main(String[] args) { ArrayList list = new ...
  • 百度这套还是有点水的,除了最后一是个简单的动态规划,需要注意下细节。 题目链接:[点这儿]. 第一:罪犯转移 ... C市现在要转移一批罪犯到D市,C市有n名罪犯,按照入狱时间有顺序,另外每个罪犯有... 枚举
  • 编程题 求最大公约数

    2020-04-28 13:56:22
    暴力枚举法 暴力枚举的方法从较小整数的一半开始,试图找到一个合适的整数 i,看看这个整数能否被 a 和 b 同时整除。 public static int getGreatestCommonDivisor(int a, int b) { int big = a > b ? a : b; ...
  • 编程题#1 来源: POJ(Coursera声明:在POJ上完成的习题将不会计入Coursera的最后成绩。) 注意: 总时间限制: 1000ms 内存限制: 65536kB 描述 下面的程序用枚举法解决如下问题,请填空。 平面上的一个矩形,如果...
  • 2.1 枚举 习题2.2 百鸡问题-哈工大上机 习题2.3 Old Bill-上交大机试 第二章 暴力求解 2.1 枚举 习题2.2 百鸡问题-哈工大上机 F&Q1:在Visual Studio中,scanf被认为是不安全的,需要用scanf_s代替。 F...
  • A)枚举类型不是基本类型 B)数组不是构造类型 C)变量必须先定义后使用 D)不允许使用空类型 解:基本类型:整型、字符型、浮点型、枚举类型。构造类型:数组类型、结构体类型、共用体类型。变量必须先定义后使用...
  • 链接:https://www.nowcoder.com/test/5583018/summary顺序从第四开始写到第一第四给出两个字符串(可能包含空格),找出其中最长的公共连续子串,输出其长度。输入描述:输入为两行字符串(可能包含空格),...
  • 昨天参加网易实习在线笔试,这是第二个编程题,当时主要是看这个题目字少,就重点想A出这个题目来,结果凉凉,嵌套两个循环,暴力枚举,结果通过10%,提示运算时间超了,想想也是,如果这么简单还用我做。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 458
精华内容 183
关键字:

枚举编程题