问电池组装用锂电池分选机

EN

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
using namespace std;

class cells {
    vector <double> cellsCap; //List of cell capacities
    vector <double> blockSum; //Block capacity
    vector <double> blockDiff; //The difference is relative to the average capacity
    int S, P; //S - In Series P - In Parallel
public:
    void Cellsfinput(const string& fname) { //File input
        ifstream fin;
        fin.open(fname);
        double intmp;

        while (fin >> intmp) {
            cellsCap.push_back(intmp);
        }
        fin.close();
    }

    void SPinput(const int& Sinp, const int& Pinp) { //S, P input for Cellsfinput.
        S = Sinp;
        P = Pinp;
        for (int i = 0; i < S; ++i) blockSum.push_back(0);
    }

    void Cellsconsinput(vector <double> cellsCapinp, const int& Sinp, const int& Pinp) { //Input from arguments
        S = Sinp;
        P = Pinp;

        for (int i = 0; i < S * P; ++i) cellsCap.push_back(cellsCapinp[i]);
        for (int i = 0; i < S; ++i) blockSum.push_back(0);
    }

    void Cellsfoutput(const string& fname) { //File output

        ofstream fout;
        fout.open(fname);

        double tmp;

        for (int i = 0; i < S; ++i) {
            fout << "Block№" << i + 1 << " ";
            tmp = 0;
            for (int k = i; k < cellsCap.size(); k += S) {
                tmp += cellsCap[k];
                fout << cellsCap[k] << ' ';

            }
            fout << "Total:" << tmp << " Diff:" << blockDiff[i] << endl;
        }

        fout.close();
    }

    void Cellsconsoutput() { //Console output
        double tmp;
        for (int i = 0; i < S; ++i) {
            cout << "Block№№" << i + 1 << " ";
            tmp = 0;
            for (int k = i; k < cellsCap.size(); k += S) {
                tmp += cellsCap[k];
                cout << cellsCap[k] << ' ';

            }
            cout << "Total:" << tmp << " Diff:" << blockDiff[i] << endl;
        }
    } 

    void sortcells() {
        sort(cellsCap.rbegin(), cellsCap.rend());

    vector <double> sortedVec; //Assembled, sorted (at the end) vector
    double midCap; //Average capacity of blocks in an assembly
        long double midTmp = 0;

        for (int i = 0; i < S * P; ++i) midTmp += cellsCap[i]; //midCap calculation
        midCap = midTmp / S;

        for (int i = P; i > 0; --i) { //Iterating through blocks
            for (int k = 0; k < S; ++k) { //Iterating through the elements in the block
                if (i == P) { //Initial filling with maximum elements (controversial decision)
                    sortedVec.push_back(cellsCap[0]);
                    blockSum[k] += cellsCap[0];
                    cellsCap.erase(cellsCap.begin());
                    continue;
                }
                for (int j = cellsCap.size() - 1; j >= 0; --j) { //Iterating over elements for parallels
                    if (j == 0) { //If there is no suitable cell, it takes the largest
                        sortedVec.push_back(cellsCap[0]);
                        blockSum[k] += cellsCap[0];
                        cellsCap.erase(cellsCap.begin());
                        break;
                    }
                    if (blockSum[k] + cellsCap[j] >= midCap / i) { //The main logic of selection takes the first element in the block that +- coincides with the average value for this "vertical".
                        sortedVec.push_back(cellsCap[j]);
                        blockSum[k] += cellsCap[j];
                        cellsCap.erase(cellsCap.begin() + j);
                        break;
                    }
                }
            }
        }
        cellsCap = sortedVec;

        for (int i = 0; i < S; ++i) blockDiff.push_back(blockSum[i] - midCap);

        /*int tmp, minDiffa, minDiffb; //Bad code
        for (int i = 0; i < S; ++i) {
            for (int k = i; k < cellsCap.size(); k += S) {
                for (int j = S - 1; j > i; --j) {
                    for (int t = j; t < cellsCap.size(); t += S) {
                        if (abs(blockDiff[i] + (cellsCap[k] - cellsCap[t])) < abs(blockDiff[i]) && abs(blockDiff[j] + (cellsCap[t] - cellsCap[j])) < abs(blockDiff[j])) {
                            cout << endl << "k:" << k << " t:" << t << " K-T: " << cellsCap[k] - cellsCap[t] << " K:" << cellsCap[k] << " T:" << cellsCap[t] << endl;
                            
                        }
                    }
                }
            }
        } */
} 
};

int main() {
    cells block;
    block.Cellsfinput("123.txt "); //Input
    block.SPinput(3, 3); //Input S (serial connection) and P (parallel connection)
    block.sortcells(); //Sorting
    block.Cellsfoutput("1234.txt "); //Output
}