C++ में मैट्रिक्स के प्रत्येक विकर्ण तत्व को आरोही क्रम में क्रमबद्ध करने का प्रोग्राम

मान लीजिए हमारे पास n x m मैट्रिक्स Mat है, हमें इस Mat को विकर्ण रूप से ऊपर-बाएं से नीचे-दाएं तक बढ़ते क्रम में क्रमबद्ध करना है, ताकि विकर्णों में सभी तत्व क्रमबद्ध हों।

उदाहरण के लिए, यदि इनपुट मैट्रिक्स है:

इसे हल करने के लिए हम निम्न चरणों का पालन करेंगे:

• solve() नामक एक विधि परिभाषित करें, जो si, sj और मैट्रिक्स mat लेती है
• n := पंक्तियों की संख्या और m := स्तंभों की संख्या
• temp नामक एक सरणी बनाएं
• i := si और j := sj, और index := 0
• जब तक i < n और j < m, करें:
  • temp में m[i][j] डालें, फिर i और j को 1 से बढ़ाएं
• temp सरणी को क्रमबद्ध करें
• index := 0, i := si और j := sj सेट करें
• जब तक i < n और j < m:
  • mat[i][j] := temp[index]
  • i, j और index को 1 से बढ़ाएं
• मुख्य विधि से:
  • n := पंक्तियों की संख्या और m := स्तंभों की संख्या
  • i को 0 से n-1 तक के लिए करें: solve(i, 0, mat)
  • j को 1 से m-1 तक के लिए करें: solve(0, j, mat)
  • mat वापस करें

उदाहरण

#include 
using namespace std;
void print_vector(vector> v){
    cout << "[";
    for(int i = 0; i> &mat){
        int n = mat.size();
        int m = mat[0].size();
        vector temp;
        int i = si;
        int j = sj;
        int idx = 0;
        while(i < n && j < m){
            temp.push_back(mat[i][j]);
            i++;
            j++;
        }
        sort(temp.begin(), temp.end());
        idx = 0;
        i = si;
        j = sj;
        while(i < n && j < m){
            mat[i][j] = temp[idx];
            i++;
            j++;
            idx++;
        }
    }
    vector> diagonalSort(vector>& mat) {
        int n = mat.size();
        int m = mat[0].size();
        for(int i = 0; i < n; i++){
            solve(i, 0, mat);
        }
        for(int j = 1; j < m; j++){
            solve(0, j, mat);
        }
        return mat;
    }
};
int main(){
    vector> v = {{3,3,1,1},{2,2,1,2},{1,1,1,2}};
    Solution ob;
    print_vector(ob.diagonalSort(v));
}

इनपुट

{{3,3,1,1},{2,2,1,2},{1,1,1,2}}

आउटपुट

[[1, 1, 1, 1, ], [1, 2, 2, 2, ], [1, 2, 3, 3, ],]