小编Dea*_*ine的帖子

我正在研究一个 HackerRank 问题，该问题在反转行和列后找到 2N x 2N 矩阵的左上象限中元素的最大总和。例如，如果矩阵是

M = [
  112  42   83   119
  56   125  56   49
  15   78   101  43
  62   98   114  108
];

那么将行和列颠倒后可以形成的最大和就是119 + 114 + 56 + 125 = 414得到矩阵后

M' = [
   119  114  42   112
   56   125  101  49
   15   78   56   43
   62   98   83   108
];

反转第 2 列和第 0 行。

我还没有找到一个简单的解决方案，但我提出了一些可能有用的事实：

• 不可能通过反转行和列来获得任何配置。因此，答案不能是简单地对所有元素进行排序并对NxN它们的顶部求和。
• 此外，不可能将任何 1 个元素移动到任何其他位置。例如，(N-1,N-1)处的元素唯一可能被移动的位置是(0,N-1),(N-1,0),(0,0)。
• 从右上象限或左下象限到左上象限需要进行 1 次行反转，从右下象限到左上象限需要进行 2 次反转。
• 不可能提出一个简单地查看左上象限中的每个元素并检查它是否可以被可移动到其位置的元素范围内的更大元素替换的解决方案（例如可以替换M[0,1]=42为 …

这涉及到我正在研究的一个更大的问题.

例如,假设我们有一个列表

9 5 6 1

在可能的三角形将有长的边

(9,5,6)
(9,6,1)
(9,5,1)
(5,6,1)

有效的(由三角不等式)是

(9,5,6)
(5,6,1)

是否有可能在更好的O(n choose 3)时间内找到那些有效的？

这是我从未理解过的.lock像示例一样,创建一个被编辑的虚拟对象几乎就像是一个黑客

class Account  
{  
    decimal balance;  
    private Object thisLock = new Object();  

    public void Withdraw(decimal amount)  
    {  
        lock (thisLock)  
        {  
            if (amount > balance)  
            {  
                throw new Exception("Insufficient funds");  
            }  
            balance -= amount;  
        }  
    }  
}  

来自https://msdn.microsoft.com/en-us/library/c5kehkcz.aspx.

为什么语言设计师不能这样做呢

class Account  
{  
    decimal balance;   

    public void Withdraw(decimal amount)  
    {  
        lock 
        {  
            if (amount > balance)  
            {  
                throw new Exception("Insufficient funds");  
            }  
            balance -= amount;  
        }  
    }  
}  

会等同吗？

所以基本上我要做的就是

static int NumdiffExponential(int[] arr, int K)
{
    return (from i in arr
            from j in arr
            where (j - i) == K
            select 1).Count();
}

除了在线性时间内,优选地使用单个LINQ查询并且以紧凑,可读和微优的方式.所以我想出的是尝试

static int NumdiffLinear(int[] arr, int K)
{
    var counters = 
        arr
        .GroupBy(i => i)
        .ToDictionary(g => g.Key, g => g.Count());
    return 
        counters
        .Keys
        .Aggregate(
            0, 
            (total, i) => total + counters[i] * (counters.ContainsKey(K - i) ? counters[K - i] : 0)
        ); 
}

它不断出现0,我无法弄清楚为什么.

让我解释一下我认为它是如何工作的.如果我们有arr={1,1,1,2,3,3,5}和K=2,然后counter像 …

或者我应该说,跳过第一个元素并在最后回到它.

比如说我有

int[] arr = { 2, 4, 3, 9, 1, 0 }; 

并希望像它一样迭代它

{ 4, 3, 9, 1, 0, 2 }

我知道一种方式会是这样的

foreach(int i in arr.Skip(1).Append(new int[] { arr.First() }))

这就是为什么我在问是否有更好看和/或更有效的方式.