题目内容

求解一个给定的方程，将x以字符串 “x=#value” 的形式返回。该方程仅包含 ‘+’ ， ‘-’ 操作，变量 x 和其对应系数。

如果方程没有解，请返回 “No solution” 。如果方程有无限解，则返回 “Infinite solutions” 。

题目保证，如果方程中只有一个解，则 ‘x’ 的值是一个整数。

示例 1：

输入: equation = “x+5-3+x=6+x-2”
输出: “x=2”

示例 2:

输入: equation = “x=x”
输出: “Infinite solutions”

示例 3:

输入: equation = “2x=x”
输出: “x=0”

提示:

3 <= equation.length <= 1000
equation 只有一个 ‘=’.
equation 方程由整数组成，其绝对值在 [0, 100] 范围内，不含前导零和变量 ‘x’

来源：力扣（LeetCode） 链接：https://leetcode.cn/problems/solve-the-equation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

首先，我们知道这个是一个一元一次方程，所以他的求解是很简单的，换句话说，如果我们的输入是告诉你左边x的系数，右边的常数，形如ax=b的形式，我们自然可以轻松给出答案。而我们这个题目的目的，就是把他的输入调整成这个格式。

首先，我们以=为界，将字符串左右分开，左右分开统计，并不影响复杂度，我们依旧是一个字符过一遍，然后，遍历左右的字符串，用string类型变量记录每一个遍历的字符，以±符号作为处理这个string变量的标志，因为可能开头就有-号，所以要提前注明这个string的长度不能为0，然后判定string的最后一位是不是x,如果是，就把掐头去尾，去掉符号和X,中间部分转数字，作为系数统计，如果不是，就只去掉前面的符号，做常数统计，左右两边各有一个系数，一个常数。最后的情况为ax+b=cx+d。

最后的操作虽然简单，但是也是我忽略了小细节的地方，我们这时候把x放左边，常数放右边。然后要先判断有没有解，是否会有无限解，这里的判定条件，我错了两次，主要是没有理清楚，最后才整理出来，先看系数，再看常数的判定逻辑。

包括最后的输出结果部分，我当时是没有用这个to_string的函数，而是直接’0’+anss了，但是这个我们现在来看显然是不对的，一来结果可能为负，二来结果大概率大于10，这样就很麻烦，我就直接改用to_string了。

代码

class Solution {
public:
    string solveEquation(string equation) {
        int biao=equation.find('=');
        string zuo=equation.substr(0,biao);
        string you=equation.substr(biao+1,equation.length());
        int zuoxi=0;int zuoshu=0;
        int youxi=0;int youshu=0;
        vector<string> os;vector<string> os2;
        string duan="";
        for(int i=0;i<zuo.length();i++){
            if(zuo[i]=='+'||zuo[i]=='-'){
                if(duan.length()==0){
                    duan+=zuo[i];
                    continue;
                }
                else{
                    os.push_back(duan);
                    duan="";
                }
            }
            duan+=zuo[i];
        }
        os.push_back(duan);
        duan="";

        for(int i=0;i<you.length();i++){
            if(you[i]=='+'||you[i]=='-'){
                if(duan.length()==0){
                    duan+=you[i];
                    continue;
                }
                else{
                    os2.push_back(duan);
                    duan="";
                }
            }
            duan+=you[i];
        }
        os2.push_back(duan);
        duan="";

        for(int i=0;i<os.size();i++){
            if(os[i][os[i].length()-1]=='x'){
                if(os[i][0]=='+'||os[i][0]=='-'){
                    if(os[i].length()==2){
                        int num=os[i][0]=='+'?1:-1;
                        zuoxi+=num;
                        continue;
                    }
                    string xishu=os[i].substr(1,os[i].length()-2);
                    int num=os[i][0]=='+'?stoi(xishu):-stoi(xishu);
                    zuoxi+=num;
                }
                else{
                    if(os[i].length()==1){
                        zuoxi+=1;
                        continue;
                    }
                    string xishu=os[i].substr(0,os[i].length()-1);                   
                    int num=stoi(xishu);
                    zuoxi+=num;
                }
            }
            else{
                if(os[i][0]=='+'||os[i][0]=='-'){
                    
                    string xishu=os[i].substr(1,os[i].length()-1);
                    
                    int num=os[i][0]=='+'?stoi(xishu):-stoi(xishu);
                    zuoshu+=num;
                }
                else{
                    string xishu=os[i];
                    int num=stoi(xishu);
                    zuoshu+=num;
                }
            }
        }



        for(int i=0;i<os2.size();i++){
            if(os2[i][os2[i].length()-1]=='x'){
                if(os2[i][0]=='+'||os2[i][0]=='-'){
                    if(os2[i].length()==2){
                        int num=os2[i][0]=='+'?1:-1;
                        youxi+=num;
                        continue;
                    }
                    string xishu=os2[i].substr(1,os2[i].length()-2);
                    int num=os2[i][0]=='+'?stoi(xishu):-stoi(xishu);
                    youxi+=num;
                }
                else{
                    if(os2[i].length()==1){
                        youxi+=1;
                        continue;
                    }
                    string xishu=os2[i].substr(0,os2[i].length()-1);                   
                    int num=stoi(xishu);
                    youxi+=num;
                }
            }
            else{
                if(os2[i][0]=='+'||os2[i][0]=='-'){
                    string xishu=os2[i].substr(1,os2[i].length()-1);
                    int num=os2[i][0]=='+'?stoi(xishu):-stoi(xishu);
                    youshu+=num;
                }
                else{
                    string xishu=os2[i];
                    int num=stoi(xishu);
                    youshu+=num;
                }
            }
        }

        int x_xi=zuoxi-youxi;
        int shu=youshu-zuoshu;
        string ans="x=";
        
        if(x_xi==0){
            if(shu!=0){
                return "No solution";
            }
            return "Infinite solutions";
        }
        
        
        else{
            int anss=shu/x_xi;
            // if(anss<0){
            //     ans+='-';
            //     anss=-anss;
            // }
            string insert=to_string(anss);
            ans+=insert;
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142