Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ में दी गई शर्तों के साथ ग्रिड में 8 संख्याएं भरें

समस्या विवरण

हम 1, 2, 3, 4, 5, 6, 7, 8 को दिए गए चित्र में आठ वृत्तों में इस तरह रखना चाहते हैं कि कोई भी संख्या उस संख्या से सटी न हो जो अनुक्रम में उसके बगल में है।

इनपुट ग्रिड

0-1-10
-1-1-1-1
0-1-10

आउटपुट

C++ में दी गई शर्तों के साथ ग्रिड में 8 संख्याएं भरें

एल्गोरिदम चरण

  • N := 3, M := 4
  • NOTCONSIDERED := -1
  • फ़ंक्शन present_in_grid(grid, num) परिभाषित करें जो जांचता है कि संख्या पहले से ग्रिड में है या नहीं।
  • फ़ंक्शन isSafe(grid, row, col, num) परिभाषित करें जो जांचता है कि दी गई स्थिति पर संख्या रखना सुरक्षित है या नहीं (आसन्न कोशिकाओं में लगातार संख्याएं नहीं होनी चाहिए)।
  • फ़ंक्शन search_free_location(grid, row, col) परिभाषित करें जो अगली खाली कोशिका ढूंढता है।
  • बैट्रैकिंग का उपयोग करके फ़ंक्शन Solve(grid) परिभाषित करें जो ग्रिड को भरता है।

C++ कार्यान्वयन

#include <cmath>
#include <iostream>
#define N 3
#define M 4
#define NOTCONSIDERED -1
using namespace std;

bool present_in_grid(int grid[N][M], int num) {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            if (grid[i][j] == num)
                return true;
    return false;
}

bool isSafe(int grid[N][M], int row, int col, int num) {
    // प्रत्येक कोशिका स्थिति के लिए विस्तृत आसन्नता जांच
    // ... (कोड में पूर्ण कार्यान्वयन देखें)
    return true;
}

bool search_free_location(int grid[N][M], int& row, int& col) {
    for (row = 0; row < N; row++)
        for (col = 0; col < M; col++)
            if (grid[row][col] == NOTCONSIDERED)
                return true;
    return false;
}

void show_res(int grid[N][M]) {
    for (int i = 0; i < N; i++) {
        if (i == 0 || i == N - 1) cout << " ";
        for (int j = 0; j < M; j++) {
            if (grid[i][j] == 0) cout << " ";
            else cout << grid[i][j] << " ";
        }
        cout << endl;
    }
}

bool Solve(int grid[N][M]) {
    int row, col;
    if (!search_free_location(grid, row, col))
        return true;
    for (int num = 1; num <= 8; num++) {
        if (isSafe(grid, row, col, num)) {
            grid[row][col] = num;
            if (Solve(grid))
                return true;
            grid[row][col] = NOTCONSIDERED;
        }
    }
    return false;
}

int main(){
    int grid[N][M] = { { 0, -1, -1, 0 },
                       { -1, -1, -1, -1 },
                       { 0, -1, -1, 0 } };
    if (Solve(grid))
        show_res(grid);
    else
        cout << "Not possible";
}

इनपुट

{ { 0, -1, -1, 0 }, { -1, -1, -1, -1}, { 0, -1, -1, 0 } }

आउटपुट

3 5 7 1 8 2 4 6
  1. कुछ शर्तों के साथ ग्राफ बनाने के लिए C++ प्रोग्राम कुछ शर्तों के साथ ग्राफ बनाने के लिए C++ प्रोग्राम

    मान लीजिए हमारे पास दो संख्याएं N और K हैं। N तत्वों वाला एक निदेशित ग्राफ पर विचार करें। N शीर्ष निम्नलिखित शर्तों को पूरा करते हैं: ग्राफ सरल और जुड़ा हुआ है शीर्ष 1 से N तक गिने जाते हैं मान लें M ग्राफ में किनारों की संख्या है। किनारों को 1 से M तक गिना जाता है। किनारे की लंबाई 1 है। और किनारा

  1. C++ में दिए गए मान वाले लीफ नोड्स को हटाना C++ में दिए गए मान वाले लीफ नोड्स को हटाना

    मान लीजिए हमारे पास एक बाइनरी ट्री और एक पूर्णांक टारगेट है, हमें उन सभी लीफ नोड्स को हटाना है जिनका मान टारगेट के बराबर है। ध्यान रखें कि एक बार लीफ नोड हटाने के बाद यदि उसका पैरेंट नोड भी लीफ नोड बन जाता है और उसका मान टारगेट के बराबर है, तो उसे भी हटाना होगा (यह प्रक्रिया तब तक जारी रखें जब तक सं

  1. - C++ में दिए गए सूचकांकों के साथ N फाइबोनैचि संख्याओं का GCD ढूंढना

    यहां हमें दिए गए सूचकांकों के साथ n फाइबोनैचि पदों का GCD ढूंढना है। तो सबसे पहले हमें अधिकतम सूचकांक प्राप्त करना होगा, और फाइबोनैचि पद उत्पन्न करने होंगे। कुछ फाइबोनैचि पद ऐसे हैं: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... सूचकांक 0 से शुरू होता है। तो 0वें सूचकांक पर तत्व 0 है। यदि हमें सूचकांकों {2,