小编Ati*_*tin的帖子

UPD.我解决了这个问题.

让我们访问城市DP[i][vertex_a][vertex_b]的州i和两个站在顶点的玩家vertex_a, vertex_b(保证其中一个站在那里list[i]).WLOG假设vertex_a ? vertex_b该DP表不包含有关球员位置的信息.只有三种状态可以达到DP[i][vertex_a][vertex_b],即DP[i + 1][vertex_a][vertex_b],DP[i + 1][list[i]][vertex_b],DP[i + 1][vertex_a][list[i]].我们还只需要存储两层DP,因此只sizeof(int) * 2 * 200 * 200需要计算最佳路径成本所需的字节数.为了获得路径,将last_move_id[i][vertex_a][vertex_b]携带关于在状态下移动的玩家的信息DP[i][vertex_a][vertex_b]并last_move_positions[i][vertex_a][vertex_b]存储玩家到达的顶点的数量list[i].由于顶点数不超过200,因此将其存储为as byte,因此sizeof(byte) * 1000 * 200 * 200每个数组都有字节.为了维护这些数组,必须有另一个数组,其中包含positions[i][vertex_a][vertex_b][3]有关每个播放器位置的信息,只需要最后两层,因此需要sizeof(byte) * 2 * 200 * 200 * 3这个字节.时间复杂O(N * L * L).

我的C++ …

我遇到了以下问题的麻烦

给定N x S网格和m个平行于水平轴的段(所有这些都是元组(x',x'',y)),回答形式(x',x'')的Q在线查询.这种查询的答案是最小的y(如果有的话),这样我们就可以放置一个段(x',x'',y).所有段都是非重叠的,但是一个段的开头可以是另一个段的结尾,即允许段(x',x',y)和(x'',x'',y).能够放置一个段意味着可能存在一个段(x',x'',y)不会违反规定的规则,段实际上并未放置(具有初始段的板未被修改)但我们只说明可能有一个.

约束

1 ? Q, S, m ? 10^5
1 ? N ? 10^9

Time: 1s
Memory: 256 Mb

以下是以下链接中的示例.输入段是(2,5,1),(1,2,2),(4,5,2),(2,3,3),(3,4,3).
回答查询

1)(1,2)→1

2)(2,3)→2

3)(3,4)→2

4)(4,5)→3

5)(1,3)→不能放置一个段

第三个查询的可视化答案(蓝色部分):

我不太明白如何处理这个问题.它应该用持久的分段树来解决,但我仍然无法想出一些东西.

请问你能帮帮我吗.

这不是我的功课.源问题可以在http://informatics.mccme.ru/mod/statements/view3.php?chapterid=111614找到.可用的语句没有英文版本,测试用例以不同的方式显示输入数据,所以不要介意源.

我试图解决以下问题:

找到具有k 1位的最小n位整数c,并且是两个n位整数的总和,其中g,h位设置为1. g,h,k <= n

首先,这里的n位整数意味着我们可以使用所有n位,即max.这样一个整数的值是2^n - 1.所描述的整数可能根本不存在.很明显,这种情况k > g + h没有解决方案,g + h = k答案只是2^k - 1(第一位k是1位,k - n前面是零).

至于程序应该做什么的一些例子:

g = h = k = 4, n = 10 :
0000001111 + 0000001111 = 0000011110
15 + 15 = 30 (30 should be the output)


(4, 6, 5, 10):
0000011110 + 0000111111 = 0001011101
30 + 63 = 93

(30, 1, 1, 31): …

有没有办法使用标准库进行漂亮优雅的加权改组？有std::discrete_distribution.我想要的是这样的:

std::vector<T> data { N elements };
std::vector<int> weights { N weights };
std::shuffle(std::begin(data), std::end(data), something based on discrete distribution);

假设我有以下代码

do {x <- (Just 3); y <- (Just 5); return (x:y:[])}

哪个输出 Just [3,5]

haskell如何知道输出值应该是Maybemonad？我的意思是return可以输出[[3, 5]].

我正在努力在C#中实现一个简单的Type转换器.我按照本指南https://msdn.microsoft.com/en-us/library/ayybcxe5.aspx

这是我的班级:

public class TestClass: TypeConverter
{
        public string Property1{ get; set; }
        public int Property2 { get; set; }
        public TestClass(string p1, int p2)
        {
            Property1= p1;
            Property2 = p2;
        }
        public override bool CanConvertFrom(ITypeDescriptorContext context,
        Type sourceType)
        {
            if (sourceType == typeof(string)) {
                 return true;
            }
            return base.CanConvertFrom(context, sourceType);
        }
        public override object ConvertFrom(ITypeDescriptorContext context,
         CultureInfo culture, object value)
        {
              if (value is string) {
                    return new TestClass ("", Int32.Parse(value.ToString()));
              }
              return base.ConvertFrom(context, culture, value);
        }
        public …

我有以下类型newtype Arr2 e1 e2 a = Arr2 { getArr2 :: e1 -> e2 -> a }。我必须为它编写 Functor 实例，但我真的不明白我是如何尝试的

instance Functor (Arr2 e1 e2) where
  fmap g (Arr2 a) = Arr2 (g a)

和

instance Functor (Arr2 e1 e2) where
  fmap g = g . getArr2

这实际上导致类型

(a -> b) -> Arr2 e1 e2 a -> b

而不是想要

(a -> b) -> Arr2 e1 e2 a -> Arr2 e1 e2 b

所以请帮帮我

社区.我有这段代码在欧几里德3D空间中找到最近的一对点.这个问题既不是关于算法也不是它的实现或其他什么.问题是,它运行显著当GCC而不是锵编译慢.最令人困惑的是,它在随机样本上具有可比较的执行时间,并且在某些特定样本上具有相似的100倍.我怀疑GCC中可能存在一个错误,因为我无法想到任何其他选项.

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <fstream>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>

static std::mt19937 mmtw(std::chrono::steady_clock::now().time_since_epoch().count());
int64_t rng(int64_t x, int64_t y) {
  static std::uniform_int_distribution<int64_t> d;
  return d(mmtw) % (y - x + 1) + x;
}

constexpr static int MAXN = 1e5 + 10;

void solve(std::istream &in, std::ostream &out);

void …

我目前正在学习 haskell 并努力应对以下测试：假设我们有这样的类型：

type Endo a = a -> a

我必须选择所有相当于 Endo (Endo Int)

(Int -> Int) -> (Int -> Int)
(Int -> Int) -> Int -> Int
Int
Int -> Int
Int -> Int -> Int -> Int
(Int -> Int) -> Int
Int -> Int -> (Int -> Int)
Int -> (Int -> Int)
Int -> Int -> Int

由于 的类型Endo Int是Int -> Int我知道我需要的类型有 4 个 Int，例如(Int -> Int) -> (Int -> Int) …

我有这样一个字符串

|   7   |      2       |39,93 |

我需要将它拆分为一个数组,其中第一个元素是"7"第二个"2"和第三个元素"39,93"

我想出了以下解决方案

var line     =  "|   7   |      2       |39,93 |";
line = line.Remove(0, 1);
string[] arr = Regex.Replace(line, @"\s+", "").Trim().Split('|');

我想知道是否有更好的方法来做到这一点.