（7、8）/48(5_15) 编程

1、合法括号序列判断

匹配不成功：

        1、当前字符不是括号字符；

        2、不完整：

                1）多出了左半边部分；

                2）多出了右半边部分；

思想：

        遍历字符串，遇到左半边，压栈操作；

        遇到右半部分，则看栈中是否有对应的左半边；

                若没有（栈空），则表示匹配不完整，多出了右半部分；

                栈不为空，则出栈与右半部分匹配成为一个完整的括号；

        遍历完毕后，如果栈不为空，表示多出了左半边。

class Parenthesis {
public:
	bool chkParenthesis(string A, int n) {
		stack<char> a;
		for (auto ch : A){
			switch (ch){
			case '(':
				a.push(ch); break;
			case ')':
				if (a.empty()){
					return false;
				}
				a.pop();
				break;
			default:
				return false;
			}
		}
		return a.empty();
	}
};

2、Fibonacci数列

输入：N

步：一步N+1、N-1；

最终目的：N最少多少步可以变为fib数

思路：找到距离N最近的两个fib数

        一个小于N（left）、一个大于N（right） 

        输出：min(N-left,right-N)

int main() {
	int a;
	while (cin >> a) {
		int f = 0, f1 = 0, f2 = 1, left, right;
		while (1){
			f = f1 + f2;
			f1 = f2;
			f2 = f;
			if (f <= a){
				left = f;
			}
			else{
				right = f;
				break;
			}
		}
		cout << min(a - left, right - a) << endl;

	}
}

3、两种排序方法

        使用向量，类型为字符串vector<string> arr，判断这些字符串，是否按照长度、字典顺序排序正确；

        设置lsort，csort标志位都为true；

        当arr[i-1]>arr[i]时，将csort置为false；注意当使用C语言时，使用strcmp函数进行判断；

        当arr[i-1].size()>arr[i].size()时，将lsort置为false；

最后通过分支语句判断应该输出什么。

int main() {
	vector<string> arr;
	int n;
	cin >> n;
	arr.resize(n);
	for (auto &s : arr){
		cin >> s;
	}
	bool lsort = true, csort = true;
	for (int i = 1; i<n; i++){
		if (arr[i - 1]>arr[i]){
			csort = false;
			break;
		}
	}
	for (int i = 1; i<n; i++){
		if (arr[i - 1].size()>arr[i].size()){
			lsort = false;
			break;
		}
	}
	if (lsort&&csort){
		cout << "both" << endl;
	}
	else if (lsort){
		cout << "lengths" << endl;
	}
	else if (csort){
		cout << "lexicographically" << endl;
	}
	else{
		cout << "none" << endl;
	}
}

4、求最小公倍数

        1）暴力求解法

        从大的数字开始，逐个判断，能够被两个数都整除的第一个数就是最小公倍数；

int main() {
    int a, b;
    while (cin >> a >> b) {
        int n=max(a,b);
        while(1){
            if((n%a==0)&&(n%b==0)){
                break;
            }
            n++;
        }
        cout<<n<<endl;
    }
}

        2）更优解法

                先计算出最大公约数：辗转相除法；

                最小公倍数=两数相乘再除以最大公约数

int yue(int a,int b){
    int c=0;
    while(c = a%b){
        a=b;
        b=c;
    }
    return b;
}

int main() {
    int a, b;
    while (cin >> a >> b) {
        cout<<(a*b)/yue(a,b)<<endl;
    }
}