C++解决一元多次不等式和多元一次不等式

一元多次不等式

思路 二分
先找到一个大致区间，然后二分出结果

二分解决多元一次不等式hdu2199

#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;
//bool ishigh(double a,double b){
//	if(8*pow(a,4)+7*pow(a,3)+2*pow(a,2)+3*a+6>b){return true;}
//	else return false;
//}
double compute(double a){
	return 8*pow(a,4)+7*pow(a,3)+2*pow(a,2)+3*a+6;
}
int main(){
	int T;
	cin>>T;
	while(T--){
		int stand;
		cin>>stand;
		double left=0,right=100,mid;
		if(compute(left)<=stand&&compute(right)>=stand)
		{
			for(int i=0;;i++)
		{
			mid=(left+right)*0.5;
			if(compute(mid)<stand){
				left=mid;
			}
			else{
				right=mid;
			}
			if(right-left<1e-8){
				break;
			}

		}
					cout<<fixed<<setprecision(4)<<mid<<endl;
	
		}
		else{
				cout<<"No solution!"<<endl;
			}
		
	}
}

多元一次方程组

解决办法：克拉默法则

思路：

• n元一次方程组的系数储存在一个二维数组中
• 计算方程组的常数的行列式的值
• 分别计算每个用常数列替换之后的行列式的值再与第二步计算出来的作比即可。
• 计算行列式的值用代数余子式，然后代数余子式要用递归，到最后二阶行列式跳出递归即可

解题中间碰到的问题：
在解决计算一个行列式的值的时候，需要用到递归，然后传一个系数矩阵进入函数，

• 然后最一开始是打算利用指针，把系数矩阵的地址传进去，但是尝试了很多方法，都没有解决。
• 然后想到直接利用当前要计算的行列式在原来的系数矩阵的位置（即传入左上角右下角就可以勾勒出要计算的行列式），但是这种方法不适用于后面求解的把行列式中的某一列用常数矩阵替换来传入求行列式的值
• 最后想到了vector来储存二维数据，直接把二维向量作为参数传进函数。（也顺带解决了后面拼接系数矩阵的问题）（向量nb～

还没来得及删注释的代码：

//
//  main.cpp
//  solve
//
//  Created by 陈冉飞 on 2019/10/26.
//  Copyright © 2019 陈冉飞. All rights reserved.
//

#include <iostream>
using namespace std;
#define maxn 10010
int n;
//double a[maxn][maxn],var[maxn][maxn],con[maxn];  //n为自变量的数量
#include <vector>
vector<vector<double>>a;
vector<vector<double>>var;
vector<double>con;

//递归计算矩阵的值
double cal(vector<vector<double>> tem){
//    cout<<tem.size()<<endl;
    double ans = 0;
    int temsize = tem.size();
    if (tem.size() == 2) return tem[0][0]*tem[1][1]-tem[1][0]*tem[0][1];
    //如果不是2*2，则用代数余子式，提取出最左边的第一列,从第一个开始算余子式
    for (int i = 0; i < tem.size(); i++) {
        vector<vector<double>> nttem;
        for (int j = 0; j < temsize; j++)
            if (i-j) {
                vector<double> inner;
                for (int k = 1; k < temsize; k++) inner.push_back(tem[j][k]);
                nttem.push_back(inner);
            }
        
        if (i%2) ans += tem[i][0]*cal(nttem);
        else ans -= tem[i][0]*cal(nttem);
    }
//    for (int i = 0; i < tem.size(); i++) {
//        for (int j = 0; j < tem[i].size(); j++) {
//            printf("%lf ",tem[i][j]);
//        }
//        printf("\n");
//    }
    return ans;
}

void solve(){
    //init var con
    var.resize(n);
    for (int i = 0; i < n; i++) {
        var[i].resize(n);
        for (int j = 0; j < n; j++) {
            var[i][j] = a[i][j];
        }
        con.push_back(a[i][n]);
    }
//    for (int i = 0; i < con.size(); i++) printf("%lf ",con[i]);
    //特判系数矩阵的值是否为零
    if (!cal(var)) {cout<<"No answer"<<endl;return;}
    else {
//        cout<<"111"<<endl;
        for (int i = 0; i < n; i++) {
//            cout<<"222"<<endl;
            vector<vector<double>> change;
            for (int j = 0; j < n; j++) {
//                cout<<"333"<<endl;
                vector<double> inner_change;
                for (int k = 0; k < n; k++) {
                    if (k == i) inner_change.push_back(con[j]);
                    else inner_change.push_back(var[j][k]);
                }
                change.push_back(inner_change);
            }
            cout<<"第"<<i<<"个解为"<<cal(change)/cal(var)<<endl;
        }
    }
//    cout<<cal(var)<<endl;;
}

int main(int argc, const char * argv[]) {
    double tem;
    while (scanf("%d",&n) && n) {
        a.resize(n);
        for (int i = 0; i < n; i++){
            a[i].resize(n+1);
            for (int j = 0; j < n+1; j++) {
                scanf("%lf",&tem);
                a[i][j] = tem;
            }
        }
        solve();
    }
    return 0;
}

删一下多余的注释来个简洁版：

//
//  main.cpp
//  solve
//
//  Created by 陈冉飞 on 2019/10/26.
//  Copyright © 2019 陈冉飞. All rights reserved.
//

#include <iostream>
using namespace std;
#define maxn 10010
int n;
#include <vector>
vector<vector<double>>a;
vector<vector<double>>var;
vector<double>con;

//递归计算矩阵的值
double cal(vector<vector<double>> tem){
    double ans = 0;
    int temsize = tem.size();
    if (tem.size() == 2) return tem[0][0]*tem[1][1]-tem[1][0]*tem[0][1];
    //如果不是2*2，则用代数余子式，提取出最左边的第一列,从第一个开始算余子式
    for (int i = 0; i < tem.size(); i++) {
        vector<vector<double>> nttem;
        for (int j = 0; j < temsize; j++)
            if (i-j) {
                vector<double> inner;
                for (int k = 1; k < temsize; k++) inner.push_back(tem[j][k]);
                nttem.push_back(inner);
            }
        
        if (i%2) ans += tem[i][0]*cal(nttem);
        else ans -= tem[i][0]*cal(nttem);
    }
    return ans;
}

void solve(){
    //init var con
    var.resize(n);
    for (int i = 0; i < n; i++) {
        var[i].resize(n);
        for (int j = 0; j < n; j++) {
            var[i][j] = a[i][j];
        }
        con.push_back(a[i][n]);
    }
    //特判系数矩阵的值是否为零
    if (!cal(var)) {cout<<"No answer"<<endl;return;}
    else {
        for (int i = 0; i < n; i++) {
            vector<vector<double>> change;
            for (int j = 0; j < n; j++) {
                vector<double> inner_change;
                for (int k = 0; k < n; k++) {
                    if (k == i) inner_change.push_back(con[j]);
                    else inner_change.push_back(var[j][k]);
                }
                change.push_back(inner_change);
            }
            cout<<"第"<<i<<"个解为"<<cal(change)/cal(var)<<endl;
        }
    }
}

int main(int argc, const char * argv[]) {
    double tem;
    while (scanf("%d",&n) && n) {
        a.resize(n);
        for (int i = 0; i < n; i++){
            a[i].resize(n+1);
            for (int j = 0; j < n+1; j++) {
                scanf("%lf",&tem);
                a[i][j] = tem;
            }
        }
        solve();
    }
    return 0;
}