Scribd
Upload
12 views

message 9

The document contains a C++ program that processes a square matrix to validate and potentially rearrange its elements based on specific conditions. It includes functions to check for the first occurrence of elements, validate row sums as an arithmetic sequence, and ensure configurations of pairs share the same boolean state. The main function reads input, builds necessary data structures, performs bit flips to find a valid configuration, and outputs the resulting matrix.

Uploaded by

pingpong player
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
12 views

message 9

The document contains a C++ program that processes a square matrix to validate and potentially rearrange its elements based on specific conditions. It includes functions to check for the first occurrence of elements, validate row sums as an arithmetic sequence, and ensure configurations of pairs share the same boolean state. The main function reads input, builds necessary data structures, performs bit flips to find a valid configuration, and outputs the resulting matrix.

Uploaded by

pingpong player
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 5

#include <bits/stdc++.

h>
using namespace std;

/**
* firstOccurrence:
* Returns 'x' if it appears first in 'matrix', otherwise returns 'y'.
* Throws runtime_error if neither is found (should not happen with valid data).
*/
int firstOccurrence(const vector<vector<int>>& matrix, int x, int y) {
int dimension = (int)matrix.size();
for (int row = 0; row < dimension; ++row) {
for (int col = 0; col < dimension; ++col) {
if (matrix[row][col] == x) return x;
if (matrix[row][col] == y) return y;
}
}
throw runtime_error("Element not found in firstOccurrence.");
}

/**
* isTableValid:
* Checks whether row sums in 'matrix' form an arithmetic sequence
* differing by exactly 'dimension' when sorted.
*/
bool isTableValid(const vector<vector<int>>& matrix) {
int dimension = (int)matrix.size();
vector<int> rowTotals(dimension, 0);
rowTotals.reserve(dimension);

for (int r = 0; r < dimension; ++r) {


for (int c = 0; c < dimension; ++c) {
rowTotals[r] += matrix[r][c];
}
}
sort(rowTotals.begin(), rowTotals.end());

for (int i = 1; i < dimension; ++i) {


if (rowTotals[i] != rowTotals[i - 1] + dimension) {
return false;
}
}
return true;
}

/**
* isConfigurationValid:
* For each pair in 'pairs', check if both values share the same boolean
* state in configBits. If any differ, return false.
*/
bool isConfigurationValid(int maxValue,
const vector<bool>& configBits,
const vector<vector<int>>& pairs)
{
// Each element of 'pairs' is a vector<int> of size 2: {a,b}
// They must share the same configBits[a] == configBits[b].
for (const auto& p : pairs) {
// Safety check: p.size() >= 2
if (p.size() >= 2) {
if (configBits[p[0]] != configBits[p[1]]) {
return false;
}
}
}
return true;
}

/**
* process:
* Main logic adapted from the original code.
* - Reads input
* - Builds frequency array and "remap" table
* - Identifies pairs for flipping
* - Does repeated bit flips until a valid configuration is found
* - Prints the resulting matrix
*/
void process(istream& input, ostream& output) {
int dimension;
input >> dimension;

// Read the grid


vector<vector<int>> matrix(dimension, vector<int>(dimension));
for (int r = 0; r < dimension; ++r) {
for (int c = 0; c < dimension; ++c) {
input >> matrix[r][c];
}
}

// Compute frequency of each value in [1 .. 2*dimension]


int maxValue = dimension * 2;
vector<int> freq(maxValue + 1, 0);
freq.reserve(maxValue + 1);
for (int r = 0; r < dimension; ++r) {
for (int c = 0; c < dimension; ++c) {
freq[matrix[r][c]]++;
}
}

// Build a 2 x (maxValue+1) "remap" table


// remap[0][val], remap[1][val]
vector<vector<int>> remap(2, vector<int>(maxValue + 1, 0));
remap[0].reserve(maxValue + 1);
remap[1].reserve(maxValue + 1);

// Build pairs for configuration


// pairs[i] = {someValue, someOtherValue} that appear exactly i times
vector<vector<int>> pairs;
pairs.reserve(dimension);

for (int i = 1; i <= dimension; ++i) {


int candidateA = 0, candidateB = 0;
// Find two values whose freq[..] == i
for (int num = 1; num <= maxValue; ++num) {
if (freq[num] == i) {
if (!candidateA) {
candidateA = num;
} else {
candidateB = num;
}
}
}

// Mapped targets
int mappedA = i + 1;
int mappedB = (maxValue + 2) - mappedA;

// Which appears first in the matrix?


int pivotA = firstOccurrence(matrix, candidateA, candidateB);
int pivotB = (candidateA == pivotA ? candidateB : candidateA);

// Fill remap
// If configBits[x] = false => pick row 0 => remap[0][x]
// If configBits[x] = true => pick row 1 => remap[1][x]
remap[0][pivotA] = mappedA;
remap[0][pivotB] = mappedB;
remap[1][pivotA] = mappedB;
remap[1][pivotB] = mappedA;

pairs.push_back({pivotA, pivotB});
}

// We'll track which values we encountered in reading matrix


// But in the original code, 'flags' was for skipping repeated?
// We'll rename it to 'seenOnce' for clarity.
vector<bool> seenOnce(maxValue + 1, false);

// forwardList & backwardList (formerly processOrder & reverseOrder)


// store distinct values from the matrix
vector<int> forwardList;
vector<int> backwardList;

forwardList.reserve(maxValue - 1);
backwardList.reserve(maxValue - 1);

// We fill forwardList/backwardList with distinct encountered values.


// The code toggles bits in 'backwardList' order.
// The original approach set a boolean array, then filled these vectors
// only once per distinct value. We'll keep the logic but do it more cleanly.
int distinctCount = 0;
for (int r = 0; r < dimension; ++r) {
for (int c = 0; c < dimension; ++c) {
int val = matrix[r][c];
if (!seenOnce[val]) {
// Mark as seen
seenOnce[val] = true;
++distinctCount;
// If there's still space in forwardList/backwardList, store it.
// The original code did if (currentIndex < size) {...}
// We'll similarly check bounds:
if ((int)forwardList.size() < maxValue - 1) {
forwardList.push_back(val);
backwardList.insert(backwardList.begin(), val);
}
}
}
}

// finalMatrix => the result


vector<vector<int>> finalMatrix(dimension, vector<int>(dimension));

// configBits => the bits we flip


// initially all 'true'
vector<bool> configBits(maxValue + 1, true);

// skipVals => values for which remap[0][i] == remap[1][i]


vector<int> skipVals;
skipVals.reserve(maxValue);

for (int i = 2; i <= maxValue; ++i) {


if (remap[0][i] == remap[1][i]) {
skipVals.push_back(i);
}
}

// The "while(true)" loop that attempts bit flips


while (true) {
// This do-while loop flips bits in backwardList order
do {
for (int val : backwardList) {
bool oldState = configBits[val];
// Flip
configBits[val] = !oldState;
// If we flipped from false -> true, break immediately
if (!oldState && configBits[val]) {
break;
}
}
} while (!isConfigurationValid(maxValue, configBits, pairs));

// If any skipVals is false => skip


bool skipThisRound = false;
for (int val : skipVals) {
if (!configBits[val]) {
skipThisRound = true;
break;
}
}
if (skipThisRound) {
// Try next iteration
continue;
}

// Build finalMatrix from configBits


for (int r = 0; r < dimension; ++r) {
for (int c = 0; c < dimension; ++c) {
int v = matrix[r][c];
// configBits[v] => pick row 1 if true, else row 0
int rowPick = configBits[v] ? 1 : 0;
finalMatrix[r][c] = remap[rowPick][v];
}
}

// Check if finalMatrix is valid


if (isTableValid(finalMatrix)) {
break; // We found a valid arrangement
}
}
// Print finalMatrix
for (int r = 0; r < dimension; ++r) {
for (int c = 0; c < dimension; ++c) {
output << finalMatrix[r][c];
if (c + 1 < dimension) {
output << ' ';
}
}
output << '\n';
}
}

int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);

process(cin, cout);
return 0;
}

You might also like