对于上下文,我编写了这个算法来获取任何字符串的唯一子串的数量.它为计算其包含的节点的字符串构建后缀树,并将其作为答案返回.我想要解决的问题需要一个O(n)算法,所以这个问题只是关于这个代码的行为方式,而不是关于它的作用有多糟糕.
struct node{
char value = ' ';
vector<node*> children;
~node()
{
for (node* child: children)
{
delete child;
}
}
};
int numberOfUniqueSubstrings(string aString, node*& root)
{
root = new node();
int substrings = 0;
for (int i = 0; i < aString.size(); ++i)
{
string tmp = aString.substr(i, aString.size());
node* currentNode = root;
char indexToNext = 0;
for (int j = 0; j < currentNode->children.size(); ++j)
{
if (currentNode->children[j]->value == tmp[indexToNext])
{
currentNode = currentNode->children[j];
j …我想弄清楚为什么会这样:
In [1]: import time, h5py as h5
In [2]: f = h5.File('myfile.hdf5', 'r')
In [3]: st = time.time(); data = f["data"].value[0,:,1,...]; elapsed = time.time() - st;
In [4]: elapsed
Out[4]: 11.127676010131836
In [5]: st = time.time(); data = f["data"][0,:,1,...]; elapsed2 = time.time() - st;
In [6]: elapsed2
Out[6]: 59.810582399368286
In [7]: f["data"].shape
Out[7]: (1, 4096, 6, 16, 16, 16, 16)
In [8]: f["data"].chunks
Out[8]: (1, 4096, 1, 16, 16, 16, 16)
如您所见,将整个数据集加载到内存中然后获取切片比从数据集中获取相同切片要快.
块大小与切片匹配,因此它应该都是连续的内存,对吧？为什么那么慢呢？
使用gzip(opts=2)压缩数据集.
在Andrew的评论之后,我运行它清除两个读取之间的缓存:
elapsed1: 11.001180410385132 …我正在构建一个光线跟踪器,在很多情况下我需要在三个浮点数上进行加法和乘法运算.
在这种情况下,我一直在以天真的方式做到这一点:
class Color{
float mR, mG, mB;
...
Color operator+(const Color &color) const
{
return Color(mR + color.mR,
mG + color.mG,
mB + color.mB);
}
Color operator*(const Color &color) const
{
return Color(mR * color.mR / COLOR_MAX,
mG * color.mG / COLOR_MAX,
mB * color.mB / COLOR_MAX);
}
}
这也会发生在等价的类中,如Point或Vect3.
然后我听说了SIMD指令,它们看起来非常适合我正在做的事情.所以,当然,我用Google搜索并找到了这段代码:
typedef int v4sf __attribute__((mode(V4SF))); // Vector of three single floats
union f4vector
{
v4sf v;
float f[4];
};
首先使用额外的四个我现在不需要.但是gcc警告我:
__attribute__ ((mode))不推荐使用指定向量类型
我想知道如何在C++ 14中做到这一点(如果它甚至完全不同),我似乎无法找到任何其他方法.
我正在寻找一种转换矢量的有效方法:
[1,1,1,2,3,3,3,4,4,4,5,1]
进入矢量矢量,使得:
[[1,2,3,12],[4],[5,6,7],[8,9,10],[11]]
一般来说:
newVector[i] = indexes of the initial vector that contained i
最好是在Matlab/Octave中,但我很好奇是否有一种有效的方法来实现这一点.
我尝试在谷歌和堆栈上查找它,但我不知道该怎么称呼这个'操作'所以没有出现.
我想从磁盘(HDF5)加载N维矩阵到std::vector对象.
我事先知道他们的等级,而不是形状.例如,其中一个矩阵是4级std::vector<std::vector<std::vector<std::vector<float>>>> data;
我想使用向量来存储值,因为它们是标准的而不像c-arrays那样难看(主要是因为它们知道它们的长度).
但是,加载它们的方法是使用一个加载函数void *,该函数采用a ,这对于1级向量可以正常工作,我可以调整它们然后访问它的数据指针(vector.data()).对于更高级别,vector.data()只会指向vectors,而不是实际数据.
最糟糕的情况我只是将所有数据加载到辅助c数组然后手动复制,但这可能会使大矩阵的速度降低很多.
有没有办法在向量中包含连续的多维数据,然后获得单个地址？
我想创建一个函数,给出两个列表(浮点数,但可以是任何东西)给出一个列表,其中包含从第一个列表中获取两个元素并将其放在最后一个中的所有组合以及前者的所有组合最后一个元素(现在有更多元素)并将它放回第一个元素.
对于每一个动作,它也会给出最大的移动值(在第二个动作中只有一个移动,即值).它应该在第一个列表为空时结束(没有第二个移动).
我不能指望任何人理解这一点,例如:
next [1,2,3,4] [] -> [(([1,2], [3,4], 4), ([1,2,3],[4],3)), (([1,2], [3,4], 4), ([1,2,4],[3],4)), (([1,3], [2,4], 4), ([1,2,3],[4],2)), (([1,3], [2,4], 4), ([1,3,4],[2],4)).....
next [1,2] [3,4] -> [(([], [1,2,3,4],2),)], ())
到目前为止我所拥有的:
module Test where
next :: [Float] -> [Float] -> [(([Float],[Float], Float),([Float],[Float], Float))]
next [] _ = []
next (a:b:[]) s
|a>b = [([],a:b:s, a)]
|otherwise = [([],a:b:s, b)]
next d s = [([x,z], i:j:s, j), b | i <- d, j <- d, i < j, x <- d, …