mirror of
https://github.com/wjakob/tbb.git
synced 2026-08-31 01:20:42 +08:00
Wenzel Jakob
78 lines
2.8 KiB
C++
78 lines
2.8 KiB
C++
/*
|
|
Copyright 2005-2016 Intel Corporation. All Rights Reserved.
|
|
|
|
This file is part of Threading Building Blocks. Threading Building Blocks is free software;
|
|
you can redistribute it and/or modify it under the terms of the GNU General Public License
|
|
version 2 as published by the Free Software Foundation. Threading Building Blocks is
|
|
distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the GNU General Public License for more details. You should have received a copy of
|
|
the GNU General Public License along with Threading Building Blocks; if not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
As a special exception, you may use this file as part of a free software library without
|
|
restriction. Specifically, if other files instantiate templates or use macros or inline
|
|
functions from this file, or you compile this file and link it with other files to produce
|
|
an executable, this file does not by itself cause the resulting executable to be covered
|
|
by the GNU General Public License. This exception does not however invalidate any other
|
|
reasons why the executable file might be covered by the GNU General Public License.
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include "tbb/parallel_for.h"
|
|
#include "tbb/blocked_range.h"
|
|
|
|
using namespace tbb;
|
|
using namespace std;
|
|
static const size_t N = 23;
|
|
|
|
class SubStringFinder {
|
|
const string str;
|
|
size_t *max_array;
|
|
size_t *pos_array;
|
|
public:
|
|
void operator() ( const blocked_range<size_t>& r ) const {
|
|
for ( size_t i = r.begin(); i != r.end(); ++i ) {
|
|
size_t max_size = 0, max_pos = 0;
|
|
for (size_t j = 0; j < str.size(); ++j)
|
|
if (j != i) {
|
|
size_t limit = str.size()-max(i,j);
|
|
for (size_t k = 0; k < limit; ++k) {
|
|
if (str[i + k] != str[j + k]) break;
|
|
if (k > max_size) {
|
|
max_size = k;
|
|
max_pos = j;
|
|
}
|
|
}
|
|
}
|
|
max_array[i] = max_size;
|
|
pos_array[i] = max_pos;
|
|
}
|
|
}
|
|
SubStringFinder(string &s, size_t *m, size_t *p) :
|
|
str(s), max_array(m), pos_array(p) { }
|
|
};
|
|
|
|
int main() {
|
|
|
|
string str[N] = { string("a"), string("b") };
|
|
for (size_t i = 2; i < N; ++i) str[i] = str[i-1]+str[i-2];
|
|
string &to_scan = str[N-1];
|
|
size_t num_elem = to_scan.size();
|
|
|
|
size_t *max = new size_t[num_elem];
|
|
size_t *pos = new size_t[num_elem];
|
|
|
|
parallel_for(blocked_range<size_t>(0, num_elem ),
|
|
SubStringFinder( to_scan, max, pos ) );
|
|
|
|
for (size_t i = 0; i < num_elem; ++i)
|
|
cout << " " << max[i] << "(" << pos[i] << ")" << endl;
|
|
delete[] pos;
|
|
delete[] max;
|
|
return 0;
|
|
}
|
|
|