[数据结构][应用] 队列的应用 乘法分配律

以下“输入顺序排序”都为先输入的先输出

一

输入：

一个乘法，乘法由两个加减法组成，两个加减法之间由括号相隔、或者没有相隔
保证每一个变量由一个字母（包括大小写）组成
若一个加减法由两个及以上个变量组成，则用括号括起来，如(a+b+c)
若只有一个正变量组成，则没有括号；如果是一个负变量，则有括号
例如该乘法可以是a(a+b+c)、(a+b+c)a、(a+b-c)(b-c+d)、aa、(-a+b)(-a)
其中左边为被乘数，如a、(a+b+c)、(a+b-c)、a、(-a+b)，右边为乘数，如(a+b+c)、a、(b-c+d)、a、(-a)

输出：

根据乘法分配律输出最终结果，分配成对的两个变量称之为对子，对子内部没有相隔，对子之间由加减'+'、'-'号隔开。
输出规则：
1. 对子内部的顺序为左边为被乘数所含的变量，右边为乘数所含的变量
2. 对子之间的顺序应该先由被乘数的输入顺序排序，相同被乘数再由乘数输入顺序排序。
3. 不处理一个对子是两个相同变量成对的情况，例如 aa
4. 不处理两个不同对子中变量相同的情况，例如 ab+ab+ba-ba
5. 如果第一个对子是正数，则不需要输出'+'；如果为负数则应该输出'-'

样例1:
输入
a(a+b+c)
输出
aa+ab+ac

样例2:
输入
(a+b+c)a
输出
aa+ba+ca

样例3:
输入
(a+b-c)(b-c+d)
输出
ab-ac+ad+bb-bc+bd-cb+cc-cd

样例4:
输入
(b-c+d)(a+b-c)
输出
ba+bb-bc-ca-cb+cc+da+db-dc

样例5:
输入
aa
输出
aa

思路：

维护三个队列，分别是被乘数、乘数、积

被乘数、乘数队列的数据为两个字符，分别代表正负符号和变量名

积的队列数据为一个字符和一个字符串，字符代表正负符号，字符串代表两个变量名相乘

循环被乘数内嵌乘数，积的正负符号等于被乘数与成熟符号的异或，积的字符串等于被乘数与乘数字符串相加

细节点：

1. 输入要分别处理被乘数（i = 0不为左括号）、乘数（i = queue.length - 1不为右括号）为单个正变量情况
2. 输入要处理括号内第一个字符是变量还是负号的情况

#include <iostream>
#include <queue>
#include <string>
#include <utility>

#define cout std::cout
#define cin std::cin
#define endl std::endl

typedef std::queue<std::pair<char,char> > pair_char;
typedef std::queue<std::pair<char,std::string> > pair_string;

void read_queue (pair_char*,pair_char*);
void Distribution (pair_char,const pair_char*,pair_string*);
void print_ans (pair_string);
int main() {
    pair_char Multiplicand; // left variable, sign and variable
    pair_char Multiplier; // right variable, sign and variable
    pair_string ans;
    read_queue(&Multiplicand,&Multiplier);
    Distribution(Multiplicand,&Multiplier,&ans);
    print_ans(ans);
    return 0;
}
void read_queue(pair_char* left,pair_char* right) {
    std::string input;
    bool flag = false; // if flag == false, input left; else input right
    bool single_left = false; // if single_left = true, means that left is single variable
    bool sign; // if sign == false, this variable is positive
    std::pair<char,char> push_data;

    cin >> input;

    for(int i = 0;i < input.length();i++) {
        if (input[i] == ')') { // input ')', change left and right
            flag = true;
            continue;
        }
        if (input[i] == '(') {
            i++; // for each first variable
            if (input[i] == '-') {
                sign = true; // '-' is near the '('
                i++;
            }
            else {
                sign = false; // means that '+'
            }
        }
        else if (i == 0 || i == (input.length() - 1)) { // if left or right is single variable
            single_left = true;
            sign = false; // it is positive '+'
        }
        else {
            if (input[i] == '-')
                sign = true;
            else
                sign = false;
            i++;
        }
        // input data
        push_data.second = input[i];
        push_data.first = sign ? '-' : '+'; // if sign == true, sign = '-'
        if(flag) { // push right
            right->push(push_data);
        }
        else {
            left->push(push_data);
        }
        flag = flag | single_left;
    }
}
void Distribution(pair_char left,const pair_char* right,pair_string *out) {
    bool flag_left;
    bool flag_right; // if flag == true, the sign of this variable is '-', else is '+'
    std::string var_left; // for left variable
    std::string var_right; //for right variable
    pair_char copy_right;

    while(!left.empty()){
        copy_right = *right; //initialization
        if(left.front().first == '-'){
            flag_left = true;
        }
        else{
            flag_left = false;
        }
        var_left = left.front().second;
        left.pop();
        while(!copy_right.empty()){
            if(copy_right.front().first == '-'){
                flag_right = true;
            }
            else{
                flag_right = false;
            }
            var_right = copy_right.front().second;
            copy_right.pop();
            if(flag_left ^ flag_right){ // xor is 0 means that '+', else is '-'
                out->push(std::make_pair('-',var_left + var_right));
            }
            else {
                out->push(std::make_pair('+',var_left + var_right));
            }
        }
    }
}
void print_ans (pair_string out){
    char sign = out.front().first;
    std::string var = out.front().second;
    out.pop();
    if(sign == '-'){
        cout << '-';
    }
    cout << var;
    while(!out.empty()){
        sign = out.front().first;
        var = out.front().second;
        out.pop();
        cout << sign << var;
    }
    cout << endl;
}

 

---

 

二

输入和输出同上述
注意同一个变量可能会输入多次
保证每一个变量由一个字母（包括大小写）组成
输出规则：
1. 对子内部的顺序由每个变量的输入顺序排序。假如b比a先输入过，即使a在被乘数中，a与b如果成对的话对子应该为 ba
2. 如果一个对子是两个相同变量成对，应该输出其次方形式，例如a*a的情况，则应该输出为 a^2 而不是aa
3. 不同对子顺序应该先由对子内左边的变量输入顺序排序，相同左边的变量之间再由右边的变量输入顺序排序。
如果为平方，则视为左边右边的变量都为该变量，例如a^2中，视为其左边与右边的变量都为a
4. 如果不同对子之间由相同两个变量成对，应该进行正常数学加减，数字与对子之间没有相隔，例如ab+ab+ab = 3ab。若数字为0则不输出该对子
5. 如果第一个对子是正数，则不需要输出'+'；如果为负数则应该输出'-'

样例1:
输入
a(a+b+c)
输出
a^2+ab+ac
Hint：变量输入顺序为a b c

样例2:
输入
(a+b+c)a
输出
a^2+ab+ac
Hint：变量输入顺序为a b c

样例3:
输入
(a+b-c)(b-c+d)
输出
ab-ac+ad+b^2-2bc+bd+c^2-cd
Hint：变量输入顺序为a b c d

样例4:
输入
(b-c+d)(a+b-c)
输出
b^2-2bc+bd+ba+c^2-cd-ca+da
Hint：变量输入顺序为b c d a

样例5:
输入
aa
输出
a^2

思路：( 笔者直接将此题跳过了，因此此思路写的比较草率，建议看下面多个乘数的思路）

维护两个队列，分别是被乘数、乘数

维护一个小根堆，为积，排序的价值是内部变量的输入顺序(从1开始)，用来给对子之间进行排序。

被乘数、乘数队列的数据为两个字符，分别代表正负符号和变量名

积的小根堆数据为一个字符和一个小根堆，小根堆用来给对子内部变量排序，价值是变量的输入顺序(从1开始)。

用内嵌循环来分配。

用专门变量分别记录 对子之间、对子内部的相同变量个数，当下一个的对子/变量不一样的时候就输出；有一个细节点就是如果为空，则强行输出。

代码略，下方代码能处理本体。

 

---

 

三

输入：

一个乘法，乘法由多个加减法组成。（上述两题都是两个）

（如果此题输入的加减法是两个，则与第二题完全一样）
输出同一、二
输出规则：
1. 对子内部的顺序由每个变量的输入顺序排序
2 若有多个相同变量成对，则应该展示其幂形式，例如 aaabbc则应该输出为 a^3b^2c
3.如果不同对子之间由相同两个变量成对，应该进行正常数学加减，数字与对子之间没有隔开，例如ab+ab+ab = 3ab。若数字为0则不输出该对子
4. 对子之间输出顺序：
设最左边的变量（不包括数字）为第一个变量，其右边的为第二个变量，以此类推；
如果变量中有次方，则应该根据次方规定其第n个变量，例如a^3b^2c中，第1~3个变量为a，第4~5个变量为b，第6个变量为c
先由第一个变量的输入顺序排序，第一个变量相同则由第二个变量输入顺序排序，以此类推;
5. 如果第一个对子是正数，则不需要输出'+'；如果为负数则应该输出'-'

样例1：
输入
(a+b-c)(b-c+d)
输出
ab-ac+ad+b^2-2bc+bd+c^2-cd

样例2：
输入
(a+b-c)a(b-c+d)
输出
a^2b-a^2c+a^2d+ab^2-2abc+abd+ac^2-acd

 

思路：

一个变量包含其变量名、符号（即下述代码的 variable）

维护一个队列，用来储存单个加减法内部的所有变量 （即下述代码的 queue<variable>)

维护一个队列，用来储存各个加减法（即下述代码的 input_que = queue<queue<variable> >）（实际上也可以vector）

维护一个小根堆，用来储存单个对子内部的变量，价值为各个变量的输入顺序 （下述代码的heap_var = priority_queue<variable>）

结构体data包含heap_var和一个char sign，sign表示整个heap_var最终得到的符号，整体异或得到

维护一个小根堆，储存data，用来表示不同对子之间的顺序，价值为每个对子的价值（下述代码的heap_data = priority_queue<data>）

积为heap_data

 

因为输入固定（是大小写字母，共48个）输入顺序价值用一个int数组表示，其中0~23为小写字母(ch - 'a')，24~47为大写字母(ch - 'A' + 24)，从1开始记录（如果为0说明没记录过）。

如果输入不固定（例如字符串），可以用map来表示价值。

输入维护一个栈，表示括号。如果输入的为变量且栈为空，则当成单独一个变量作为队列压入 input_que

乘法分配类似于排列组合，用递归枚举即可1

最终输出检测对子内部、对子之间的相同个数（在data、variable分别写一个“==”的operator）

对子之间的个数要注意：如果大于2或者小于-2，就输出数字；如果为1就不输出数字（但是要注意是否输出符号）；如果为0就不输出；如果为负数可以直接输出数字不输出负号，但是要特殊处理 -1的情况

代码：

#include <iostream>
#include <queue>
#include <stack>
#include <string>

#define cout std::cout
#define cin std::cin
#define endl std::endl

struct variable{
    char var;
    char sign;
    int value;
    bool operator < (const variable p) const {
        return this->value > p.value; // small root heap
    }
    bool operator == (const variable p) const {
        return this->var == p.var;
    }
};
typedef std::priority_queue<variable> heap_var;
struct data {
    heap_var que_var;
    char sign;
    data() : que_var(heap_var{}), sign('-'){}
    // ensure this->size == p.size
    bool operator < (const data &p) const { // small root heap same as "variable"
        heap_var left = this->que_var;
        heap_var right = p.que_var;
        while(!left.empty()) {
            if(left.top() == right.top()) { // top equal
                left.pop();
                right.pop();
            }
            else {
                return left.top() < right.top(); // not equal, small root
            }
        }
        return left.top() < right.top(); // all equal
    }
    bool operator == (const data &p) const {
        if (this->que_var.size() != p.que_var.size())
            return false;
        heap_var left = this->que_var;
        heap_var right = p.que_var;
        while(!left.empty()) {
            if(left.top() == right.top()) { // top equal
                left.pop();
                right.pop();
            }
            else {
                return false; // not equal
            }
        }
        return true; // all equal
    }
    void calc_sign() {
        bool flag_sign_final = false; // flag_sign == 1 means that sign == '-'
        heap_var copy_var = this->que_var;
        while(!copy_var.empty()){
            bool flag_sign_heap = (copy_var.top().sign == '-') ? true:false;
            flag_sign_final ^= flag_sign_heap;
            copy_var.pop();
        }
        this->sign = flag_sign_final? '-':'+';
    }
};
typedef std::queue<std::queue<variable> > input_que; // queue for queue of variable
typedef std::priority_queue<data> heap_data;

int var_value[48] = {0}; // for 0~23: value of 'a'~'z'; 24 ~ 47: value of 'A'~'Z"

void read_queue(input_que *que);
void Distribution(input_que,data,heap_data*);
void print_heapdata(heap_data);

int main() {
    input_que que;
    heap_data ans;

    read_queue(&que);
    Distribution(que,data(),&ans);
    print_heapdata(ans);
    return  0;
}

void read_queue(input_que *que) {
    std::string input;
    std::stack<char> flag; // for brackets
    std::queue<variable> que_var; // for each queue variable
    variable var = {}; // for each input variable
    bool sign = false; // for sign == true, means this variable is negative; false means is positive
    int input_value = 1; // for value of variable while input

    cin >> input;
    for(int i = 0;i < input.length();i++){
        if(input[i] == '(')
            flag.push(input[i]);
        else if(input[i] == ')'){
            flag.pop();
            que->push(que_var); // push to queue for queue of variable
            while(!que_var.empty()) // clear queue of variable
                que_var.pop();
        }
        else if(input[i] == '+')
            sign = false;
        else if(input[i] == '-')
            sign = true;
        else { // else means that input is variable
            int num;
            if(input[i] >= 'a' && input[i] <= 'z')
                num = input[i] - 'a';
            else
                num = input[i] - 'A' + 24;
            if(var_value[num] == 0) // if never input this variable
                var_value[num] = input_value++;

            // initialization fot this variable
            var.var = input[i];
            var.value = var_value[num];
            var.sign = sign ? '-':'+'; // true->'-'; false->'+'
            que_var.push(var);
            if(flag.empty()){ // for single variable, exit now queue of variable
                que->push(que_var);
                que_var.pop();
            }
            sign = false; // initialization for each variable to '+'
        }
    }
}
void Distribution(input_que que,data Data,heap_data* heapData) { // Recursive traversal queue for queue of variable
    if(que.empty()) { // leaf, data pushed into heapData
        Data.calc_sign(); // calculate sign
        heapData->push(Data);
        return;
    }
    std::queue<variable> que_var = que.front();
    que.pop();
    while(!que_var.empty()){
        variable var = que_var.front();
        data copy_Data = Data; // flash back
        copy_Data.que_var.push(var);
        Distribution(que,copy_Data,heapData);
        que_var.pop();
    }
}
void print_heapdata(heap_data heapData){
    bool firstdata = false; // for fist input

    data next_data;
    data this_data;
    int num_data = 0;
    while(!heapData.empty()){
        this_data = heapData.top();
        heapData.pop();
        if(!heapData.empty())
            next_data = heapData.top();
        else
            next_data = data(); // if empty, not same data

        // calculate the number of same data
        if(this_data.sign == '+')
            num_data++;
        else
            num_data--;

        // same data, continue
        if (next_data == this_data) {
            continue;
        }
        // 0, not print
        if (num_data == 0) {
            num_data = 0;
            continue;
        }

        // print sign
        if (firstdata && num_data > 0){
            cout << '+';
        }
        else if(num_data == -1) {
            cout << '-';
        }
        else{
            firstdata = true;
        }
        // print number of data
        if(num_data >= 2 || num_data <= -2)
            cout << num_data;
        num_data = 0;

        // for print variable
        char this_var;
        char next_var;
        int num_char = 0;
        while(!this_data.que_var.empty()) {
            this_var = this_data.que_var.top().var;
            num_char++;
            this_data.que_var.pop();
            // for next variable
            if (!this_data.que_var.empty())
                next_var = this_data.que_var.top().var;
            else
                next_var = '0'; // if empty, print.
            // print
            if (next_var != this_var) {
                cout << this_var;
                if(num_char >= 2) { // print '^'
                    cout << '^' << num_char;
                }
                num_char = 0;
            }
        }
    }
}

 

 

---