געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ


שוועריקייט לעוועל מיטל
אָפט געבעטן אין 24 * 7 יננאָוואַטיאָן לאַבס אַקסענטורע עקספּעדיאַ יבם דזשפּ מאָרגאַן קוואָראַ
מענגע האַש האַשינג מאַטריץ

פּראָבלעם סטאַטעמענט

געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ שטאַטן אַז איר האָט אַ מאַטריץ פון גרייס m * n און אַ מאַטריץ רודערן נומער זאגט 'רודערן'. די פּראָבלעם ויסזאָגונג פרעגט צו געפֿינען אַלע די מעגלעך ראָוז וואָס זענען פּערמיוטייטיד צו די געגעבן רודערן. דאָס איז אויך געזאגט אַז אַלע עלעמענטן אין יעדער רודערן זענען אַנדערש.

בייַשפּיל

r = 2

mat[][] = {{6, 5, 9, 2},

{1, 6, 9, 3},

{6, 5, 9, 2},

{6, 2, 5, 9}}
0, 3

דערקלערונג: די געגעבן רודערן איז 2 וואָס כּולל 6, 5, 2 און 9. מיט דעם בלויז 0th און קסנומקסrd רודערן זענען די פּערמיוטיישאַנז צו די געגעבן רודערן נומער.

 

אַלגערידאַם צו געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ

1. Create a set.
2. Insert the given row elements into the set.
3. Traverse the matrix, and ignore the given row number while traversing.
    1. Check if the set doesn’t contain each value of the traversed row if it doesn’t contain then break the loop and proceed for next row.
    2. Else print the value of i, i.e, the current row number.

 

דערקלערונג

איר באַקומען אַ מאַטריץ פון זאָגן m ראָוז און N שפאלטן און די רודערן נומער, די רודערן נומער איז 0 אינדעקס-באזירט. מיר האָבן געבעטן צו געפינען אויס אויב די ראָוז אין די מאַטריץ אנדערע ווי די געגעבן רודערן וואָס זענען פּערמיוטיישאַנז פון אַ געגעבן רודערן. פּערמיוטיישאַן דאָ מיטל אַז מיר מוזן געפֿינען זיך די יסודות אין דער געגעבן רעשימע זענען די זעלבע אין ווי פילע רשימות, אָדער האָבן די זעלבע רשימות אָדער נישט. מיר דאַרפֿן צו דרוקן דעם רודערן נומער. פֿאַר דעם, מיר וועלן נוצן שטעלן.

ערשטער, מיר דאַרפֿן צו שטעלן אַלע די וואַלועס פון די געגעבן רודערן נומער אין דעם גאַנג. דאָס איז באהאנדלט ווי אַ רעפֿערענץ אין אונדזער שפּעטער אַפּעריישאַנז. מיר האָבן סטאָרד דעם רודערן אין דעם גאַנג. ווייַל מיר וועלן פאַרגלייכן דאָס מיט אַלע אנדערע ראָוז אַחוץ זיך.

אַריבער די מאַטריץ איצט מיט די נעסטעד שלייף. מיר וועלן קלייַבן יעדער רודערן און מיט די רודערן, מיר וועלן דורכפאָר אַלע עלעמענטן. מיר האָבן דערמאנט אַ פאַל אויב די רודערן וואָס מיר וועלן קלייַבן זיך איז די זעלבע ווי די געגעבן רודערן. איגנאָרירן עס און מאַך צו די ווייַטער רודערן אויב עס איז פאָרשטעלן. דאָס איז ווייַל מיר וואָלט נישט לייגן אַ מער ווערט צו דעם ענטפער. און עס ווייזט איינער מער ריי עקסטרע וואָס איז ריי זיך. דאָס וואָלט נישט זיין פּאַסיק. איצט ווען מיר פאָרן דורך די עלעמענטן פון דער פּיקט רודערן, מיר וועלן קאָנטראָלירן אויב דער גאַנג כּולל די שטעלן עלעמענט ווי מיר פּיקינג אַרויף. אויב די שלייף טוט נישט ברעכן אין אַלע און קומט דעם מיטל, די געגעבן רודערן איז פּערמיוטייטיד און מיר וועלן דרוקן די רודערן נומער. גיינ ווייַטער ווייַטער צו געפֿינען מער ראָוז זענען פּערמיוטייטיד אָדער נישט.

געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ

קאָדעקס

C ++ קאָד צו געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ

#include<iostream>
#include<unordered_set>

#define MAX 100

using namespace std;

void checkPermutatedRow(int matrix[][MAX], int m, int n, int r)
{
    unordered_set<int> s;

    for (int j=0; j<n; j++)
        s.insert(matrix[r][j]);

    for (int i=0; i<m; i++)
    {
        if (i==r)
            continue;

        int j;
        for (j=0; j<n; j++)
            if (s.find(matrix[i][j]) == s.end())
                break;
        if (j != n)
            continue;

        cout << i << ", ";
    }
}
int main()
{
    int row = 4, col = 4,r = 2;
    int matrix[][MAX] = {{6, 5, 9, 2},
        {1, 6, 9, 3},
        {6, 5, 9, 2},
        {6, 2, 5, 9}
    };
    checkPermutatedRow(matrix, row, col, r);
    return 0;
}
0, 3,

Java Code צו געפֿינען אַלע פּערמיוטאַד ראָוז פון אַ געגעבן רודערן אין אַ מאַטריץ

import java.util.LinkedHashSet;

class Permutations
{
    private static int MAX = 100;

    public static void checkPermutatedRow(int matrix[][], int m, int n, int r)
    {
        LinkedHashSet<Integer> SET = new LinkedHashSet<>();

        for (int j = 0; j < n; j++)
            SET.add(matrix[r][j]);

        for (int i = 0; i < m; i++)
        {
            if (i == r)
                continue;

            int j;
            for (j = 0; j < n; j++)
                if (!SET.contains(matrix[i][j]))
                    break;
            if (j != n)
                continue;

            System.out.print(i+", ");
        }
    }
    public static void main(String[] args)
    {
        int  row= 4, col = 4,r = 2;
        int matrix[][] = {{6, 5, 9, 2},
            {1, 6, 9, 3},
            {6, 5, 9, 2},
            {6, 2, 5, 9}
        };
        checkPermutatedRow(matrix, row, col, r);
    }
}
0, 3,

 

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (m * n) ווו "עם" און “N” איז די נומער פון ראָוז און שפאלטן אין די מאַטריץ. זינט מיר נאָר דורכפאָר די מאַטריץ און סאַסינג האַססעט פּראָווידעס צו דורכפירן אַפּעריישאַנז אין אָ (1).

ספעיס קאַמפּלעקסיטי

אָ (N) ווו "N" איז די נומער פון עלעמענטן אין דער מאַטריץ. זינט מיר נאָר סטאָרד די אַרייַנשרייַב, אַזוי די אַלגערידאַם האט לינעאַר פּלאַץ קאַמפּלעקסיטי.