ue 抗锯齿渲染序列失灵_最大的锯齿形序列

ue 抗锯齿渲染序列失灵

Problem statement:

问题陈述：

Given a square matrix of size n x n, find the sum of the Zigzag sequence with the largest sum. A zigzag sequence starts from the top and ends at the bottom. Two consecutive elements of sequence cannot belong to the same column.

给定大小为nxn的方阵， 找到Zigzag序列的总和最大 。 之字形序列从顶部开始，在底部结束。序列的两个连续元素不能属于同一列。

    Input:
First line contains an integer N denoting the size of the matrix. 
Then in the next line are N*N space separated values of the matrix.
Output:
Print the required max sum.
Constraints:
1<=N<=100
1<=M[][]<=1000

Example:

例：

    Input:
Input matrix
3 8 2
4 8 5
6 9 7
Output: 22
Maximum Zigzag sequence is: 
8->5->9
Other sequences can be: 
3->8->6 etc.
Input:
Input matrix
3  2  1
10 8  5 
6  6  4
Output: 18
In the above also, the maximum zigzag sequence will be:
2->10->6

The second example clearly shows that the greedy solution wouldn't work. Let's say we opt for greedy technique and as a measure, what we do is to extract local maximum, i.e., to extract maximum out of this row and the go-ahead to the next row and find out maximum skipping the column where we found our last maximum.

第二个例子清楚地表明，贪婪的解决方案是行不通的。假设我们选择贪婪技术，并且作为一种度量，我们要做的是提取局部最大值，即从该行中提取最大值，然后继续到下一行，并找出最大值，跳过找到我们的列最后的最大值。

So if we follow a similar approach, let's check what we can lead to.

因此，如果我们采用类似的方法，那么让我们检查一下会导致什么。

So, firstly, we will pick 3 out of the first row (0^th row)

因此，首先，我们将从第一行( ^第 0行)中选择3 ^个

From the next row, we will pick 8 as we can't peek 10 due to out constraint.

在下一行中，我们将选择8 ，因为由于出局限制我们无法窥视10 。

And from the next row, we will pick 6 (of 0^th column)

然后从下一行中，选择6 ( ^第 0列)

So it sums up to 3+8+6 which is 17. But it's wrong we know output would be 18. So finding local best doesn't lead to global best. Hence, greedy will not work here.

因此，总和为3 + 8 + 6 ，即17 。但是我们知道输出为18是错误的。因此，找到本地最佳并不能带来全球最佳。因此，贪婪在这里不起作用。

We need dynamic programing or recursion to solve.

我们需要动态编程或递归来解决。

Solution Approach:

解决方法：

So, let's see what can be a recursive solution. Then, we will check for overlapping sub-problems and will gradually optimize the recursion by memorization.

因此，让我们看看什么是递归解决方案。然后，我们将检查重叠的子问题，并通过记忆逐步优化递归。

Let the recursive function be, recurZigzag(matrix, cur_row, cur_colulm, n)

设递归函数为recurZigzag(matrix，cur _row ，cur _colulm ，n)

    Function recurZigzag(matrix,cur_row,cur_colulm):
If (cur_row reaches n)
Return 0;
for i=0 to n except cur_column
Return  matrix[cur_row][cur_column] + max(recurZigzag(matrix, cur_row + 1, i))
End Function
// In the main function
for column=0 to n-1
result=max⁡(result,recurZigzag(matrix,0,column)

So what we did?

那我们做了什么？

We are starting from each column on the top row.

我们从第一行的每一列开始。

Then we are recursively checking for the next row skipping the current column. So, this checks all combinations possible.

然后，我们递归地检查跳过当前列的下一行。因此，这将检查所有可能的组合。

I would recommend to create the recursion tree for example 1 and check whether you can find overlapping sub-problems. There will be a lot of overlapping problems even for smaller inputs.

我建议为示例1创建递归树，并检查是否可以找到重叠的子问题。即使对于较小的输入，也会有很多重叠的问题。

So, we need to pass that overhead and we can solve that by memorization technique where we store the value of solved sub-problem in DP[][]

因此，我们需要传递该开销，并且可以通过存储将已解决子问题的值存储在DP [] []中的记忆技术来解决该问题。

So, we first lookup in DP[][] whether it's already solved or not. If it's already solved then we will have some value for DP[i][j] (for subproblem, f(i,j)), Else DP[i][j] will contain the initialized value only.

因此，我们首先在DP [] []中查找它是否已解决。如果已经解决，则DP [i] [j]会有一些值(对于子问题f(i，j) )，其他DP [i] [j]仅包含初始化值。

This is the trick here.

这是这里的把戏。

Below is the full CPP implementation for understanding memorization.

以下是用于理解记忆的完整CPP实施。

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;
int findmax(vector<int> arr, int in, int n, int* lastindex)
{
int max = INT_MIN;
for (int i = 0; i < n; i++) {
if (arr[i] > max && i != in) {
max = arr[i];
*lastindex = i;
}
}
return max;
}
int recurZigZag(vector<vector<int> > arr, int row, int col, int n, int** dp)
{
//memoization part
if (dp[row][col] != -1) //if already solved, no need to compute again
return dp[row][col];
if (row == n - 1) {
dp[row][col] = arr[row][col];
return arr[row][col];
}
int max = INT_MIN;
for (int k = 0; k < n; k++) {
if (k != col) {
int t = recurZigZag(arr, row + 1, k, n, dp);
if (max < t)
max = t;
}
}
dp[row][col] = std::max(dp[row][col], arr[row][col] + max); //store solution
return dp[row][col];
}
int main()
{
int t, n, item;
cout << "Enter test case:\n";
cin >> t;
for (int i = 0; i < t; i++) {
cout << "Input size of square matrix\n";
cin >> n;
vector<vector<int> > arr;
cout << "Input the square matrix\n";
for (int i = 0; i < n; i++) {
vector<int> inn;
for (int j = 0; j < n; j++) {
cin >> item;
inn.push_back(item);
}
arr.push_back(inn);
}
int** dp = (int**)(malloc(sizeof(int*) * n));
for (int i = 0; i < n; i++) {
dp[i] = (int*)(malloc(sizeof(int) * n));
for (int j = 0; j < n; j++)
dp[i][j] = -1;
}
int mymax = INT_MIN;
for (int i = 0; i < n; i++) {
int p = recurZigZag(arr, 0, i, n, dp);
if (p > mymax)
mymax = p;
}
cout << "Maximum zigzag sum: " << mymax << endl;
}
return 0;
}

Output

输出量

Enter test case:
2
Input size of square matrix 
3
Input the square matrix  
3 8 2  
4 8 5  
6 9 7  
Maximum zigzag sum: 22
Input size of square matrix 
3
Input the square matrix  
3 2 1  
10 8 5 
6 6 4  
Maximum zigzag sum: 18