void ContigGraph::GetContigs(deque<Sequence> &contigs, deque<ContigInfo> &contig_infos)
{
contigs.resize(vertices_.size());
contig_infos.resize(vertices_.size());
#pragma omp parallel for
for (int64_t i = 0; i < (int64_t)vertices_.size(); ++i)
{
contigs[i] = vertices_[i].contig();
contig_infos[i] = vertices_[i].contig_info();
}
}
bool ReadHashAlignerRecords(FILE *fp, deque<HashAlignerRecord> &records)
{
int size = 0;
if (fread(&size, sizeof(int), 1, fp) != 1)
return false;
records.resize(size);
for (unsigned j = 0; j < records.size(); ++j)
{
if (fread(&records[j], sizeof(HashAlignerRecord), 1, fp) != 1)
{
records.resize(j);
return false;
}
}
return true;
}
/**
* Convert the array of bytes into an array of ints
*/
bool decode_bytes(const vector<UINT8>& in_data, deque<int>& out_data)
{
out_data.resize(in_data.size());
for (int idx = 0; idx < (int)in_data.size(); idx++)
{
out_data[idx] = in_data[idx];
}
return true;
}
void initParticles()
{
particles.resize(OPT_NUM_INITIAL_PTLS);
deque<cParticle>::iterator ptlIter;
for( ptlIter = particles.begin(); ptlIter != particles.end(); ptlIter ++ )
{
ptlIter->active = false;
}
cModel dummyModel;
texId = dummyModel.loadTexture(OPT_PATH_TEXTURES + (string)"particle" + OPT_PATHEXT_TEXTURES);
}
int main (){
long long x;
cin>>x;
for (int cas = 1; cas <= x; ++cas){
cin>>n>>k>>a>>b>>c>>r;
arr.resize(k);
memset(mapa,0,sizeof mapa);
//REACH;
OUTPUT(solve());
// print_arr();
}
}
/* Function: addProcessBlockByBurst
* Usage: deque<processBlock> p
* addProcessBlockByBurst(b, bs);
* -------------------------------------------
* Adds the processBlock in the apporpriate position in the vector,
* keeps it sorted by the processescpu burst time from least to greatest.
*/
void addProcessBlockByBurst(processBlock & b, deque<processBlock> & bs)
{
if(bs.size()==0 || b.p.burst >= bs.back().p.burst )
bs.push_back(b);
else
{
int i = (int)bs.size()-1;
bs.resize(bs.size()+1);
do
{
bs[i+1] = bs[i];
i--;
} while(i>=0 && b.p.burst<bs[i].p.burst);
bs[i+1] = b;
}
}
// Searches for an augmenting path rooted at r via a breadth first search.
bool BFS(int r) {
if (graph[r].size() == 0) return false;
// Set up union-find (initially, all nodes are their own representatives)
// Reset lca and d memory, we cut this time from the total recorded.
time_t t = clock();
for (int i = 0; i<n; ++i) pp[i] = i;
memset(v, -1, sizeof(v));
memset(d, -1, sizeof(d));
mem_time += clock() - t;
// Initialize values and push root onto the queue.
q.resize(0);
d[r] = 0;
q.push_front(r);
while (!q.empty()) {
// Pop front of queue, take to be the current node, x.
// Iterate over all neighbours of the current node, y.
int this_is_dumb = q.front(); q.pop_front();
for (int x = this_is_dumb, i = 0, y = graph[x][0]; i < (int)graph[x].size(); ++i, y = graph[x][i]) {
if (m[y] != y && f(x) != f(y)) { // if neighbour not unmatchable and not in blossom with x:
if (d[y] == -1) { // if neighbour not in tree yet:
if (m[y] == -1) { // if neighbour not matched:
path(r, x);
m[x] = y;
m[y] = x;
return true; // AUGMENTING PATH FOUND, update m and return
} else { // if neighbour matched:
p[y] = x; // update tree growing structure (m and d)
p[m[y]] = y; // and push y's match onto queue.
d[y] = 1;
d[m[y]] = 0;
q.push_front(m[y]);
}
} else if (d[f(y)] == 0) { // if root-distance to neighbour known and even
int b = lca(x, y, r); // then we have found a blossom.
shrink_one_side(x, y, b); shrink_one_side(y, x, b);
}
}
}
}
return false;
}
void topological_sort1(graph_list g, deque<graph_node>& topo)
{//图G有g_l.size()个节点，下标从0到g_l.sizeZ()-1
//返回的队列中的节点顺序即为拓扑序列
topo.resize((int)g.g_l.size());
int visited[MAX], time(0);
memset(visited, 0, MAX * sizeof(int));
for(int i = 0; i < (int)g.g_l.size(); ++ i)
topo[i].g_idx = i;
for(int i = 0; i < (int)g.g_l.size(); ++ i)
if(!visited[i])
dfs_visit(g, i, visited, time);
for(int i = 0; i < (int)g.g_l.size(); ++ i)
topo[i].g_value = g.g_l[i][0].g_value;
//按照dfs搜索到的时间排序，时间大的在前面，小的在后
//可以认为时间最小的是dfs次数最少的节点，即拓扑排序中最后面的节点
//而dfs次数最大的节点是起始节点
sort(topo.begin(), topo.end(), compare);
}
int main() {
int X, Y, T = 0;
char input[2];
while( scanf( "%d%d", &M, &N ) != EOF ) {
if( T++ ) putchar( '\n' );
for( int i = 0; i < M; i++ )
scanf( "%s", grid[i] );
scanf( "%d%d%s", &X, &Y, input );
Force.resize( 0 );
Force.push_back( oper( X - 1, Y - 1, *input ) );
while( !Force.empty() ) {
knockDown( Force[0].x, Force[0].y, Force[0].c );
Force.pop_front();
}
for( int i = 0; i < M; i++ )
printf( "%s\n", grid[i] );
}
}
IDBAOption()
{
extra_read_files.resize(4);
directory = "out";
mink = 20;
maxk = 50;
step = 10;
inner_mink = 10;
inner_step = 5;
prefix_length = 3;
min_count = 2;
min_support = 1;
min_contig = 200;
similar = 0.95;
max_mismatch = 3;
seed_kmer_size = 30;
num_threads = 0;
min_pairs = 3;
max_gap = 50;
is_no_local = false;
is_no_coverage = false;
is_no_correct = false;
is_pre_correction = false;
}
int main() {
ios::sync_with_stdio(false);
int M, K, imax, tmp;
char C, X;
stack <int> S;
cin >> N >> M;
A.resize(N+1);
for(int i = 1; i<=N ; i++)
cin >> EL(i);
for(int i = N ; i >= 1 ; i--) {
while(!S.empty() && (EL(S.top()) <= EL(i))) S.pop();
if(S.empty()) {TIMES(i) = N-i; S.push(i);}
else {TIMES(i) = S.top()-i-1; S.push(i);}
}
while(!S.empty()) S.pop();
for(int i = 1 ; i <= N ; i++) {
while(!S.empty() && (EL(S.top()) < EL(i))) S.pop();
if(S.empty()) {tmp = TIMES(i)*(i-1); TIMES(i) += (i+tmp); S.push(i);}
else {tmp = TIMES(i)*(i-S.top()-1); TIMES(i) += (i-S.top()+tmp); S.push(i);}
}
sort(++A.begin() , A.end() , comp);
print();
int count = TIMES(1), dup = 0;
for (it1 i = A.begin(); i != --A.end() ; ) {
if ((i+1)->first == i->first) {
i = A.erase(i);
count += i->second;
dup++;
} else {
i->second = count;
count = (i+1)->second;
++i;
}
} (*(--A.end())).second = count; N -= dup;
print();
for(int i = N-1 ; i>=1 ; i--)
TIMES(i) += TIMES(i+1);
//print();
lli freq;
for(int i = 1 ; i<=M ; i++) {
cin >> C >> K >> X;
switch(C) {
case '<':
if(K > EL(1)) freq = TIMES(1);
else if(K <= EL(N)) freq = 0;
else freq = query(1 , N , C , K);
break;
case '>':
if(K < EL(N)) freq = TIMES(1);
else if(K >= EL(1)) freq = 0;
else freq = query(1 , N , C , K);
break;
case '=':
if(K > EL(1) || K < EL(N)) freq = 0;
else freq = query(1 , N , C , K);
break;
}
cout << C << " " << K << " :\t" << freq;
// if(freq %2) cout << ((X == 'D')?"D":"C");
// else cout << ((X == 'D')?"C":"D");
cout << endl;
}
return 0;
}
void
OnLineFootTrajectoryGeneration::interpolate_feet_positions(double Time,
const deque<support_state_t> & PrwSupportStates_deq,
const solution_t & Solution,
const deque<double> & PreviewedSupportAngles_deq,
deque<FootAbsolutePosition> & FinalLeftFootTraj_deq,
deque<FootAbsolutePosition> & FinalRightFootTraj_deq)
{
support_state_t CurrentSupport = PrwSupportStates_deq.front();
double FPx(0.0), FPy(0.0);
if(CurrentSupport.Phase != DS)
{
unsigned int NbStepsPrwd = PrwSupportStates_deq.back().StepNumber;
interpret_solution( Time, Solution, CurrentSupport, NbStepsPrwd, FPx, FPy );
}
double LocalInterpolationStartTime = Time-(CurrentSupport.TimeLimit-(m_TDouble+m_TSingle));
int StepType = 1;
unsigned int CurrentIndex = FinalLeftFootTraj_deq.size()-1;
FootAbsolutePosition * LastSFP; //LastSwingFootPosition
if(CurrentSupport.Foot == LEFT)
{
LastSFP = &(FinalRightFootTraj_deq[CurrentIndex]);
}
else
{
LastSFP = &(FinalLeftFootTraj_deq[CurrentIndex]);
}
FinalLeftFootTraj_deq.resize((unsigned int)(QP_T_/m_SamplingPeriod)+CurrentIndex+1);
FinalRightFootTraj_deq.resize((unsigned int)(QP_T_/m_SamplingPeriod)+CurrentIndex+1);
if(CurrentSupport.Phase == SS && Time+1.5*QP_T_ < CurrentSupport.TimeLimit)
{
//determine coefficients of interpolation polynome
double ModulationSupportCoefficient = 0.9;
double UnlockedSwingPeriod = m_TSingle * ModulationSupportCoefficient;
double EndOfLiftOff = (m_TSingle-UnlockedSwingPeriod)*0.5;
double SwingTimePassed = 0.0;
if(LocalInterpolationStartTime>EndOfLiftOff)
SwingTimePassed = LocalInterpolationStartTime-EndOfLiftOff;
//Set parameters for current polynomial
double TimeInterval = UnlockedSwingPeriod-SwingTimePassed;
SetParameters(
FootTrajectoryGenerationStandard::X_AXIS,
TimeInterval,FPx,
LastSFP->x, LastSFP->dx, LastSFP->ddx, LastSFP->dddx
);
SetParameters(
FootTrajectoryGenerationStandard::Y_AXIS,
TimeInterval,FPy,
LastSFP->y, LastSFP->dy, LastSFP->ddy, LastSFP->dddy
);
if(CurrentSupport.StateChanged==true)
{
SetParameters(FootTrajectoryGenerationStandard::Z_AXIS,
m_TSingle,/*m_AnklePositionLeft[2]*/0.0,
LastSFP->z, LastSFP->dz, LastSFP->ddz
);
}
int index_orientation = PrwSupportStates_deq[1].StepNumber ;
SetParameters(
FootTrajectoryGenerationStandard::THETA_AXIS,
TimeInterval, PreviewedSupportAngles_deq[index_orientation]*180.0/M_PI,
LastSFP->theta, LastSFP->dtheta, LastSFP->ddtheta);
SetParametersWithInitPosInitSpeed(
FootTrajectoryGenerationStandard::OMEGA_AXIS,
TimeInterval,0.0*180.0/M_PI,
LastSFP->omega, LastSFP->domega);
SetParametersWithInitPosInitSpeed(
FootTrajectoryGenerationStandard::OMEGA2_AXIS,
TimeInterval,2*0.0*180.0/M_PI,
LastSFP->omega2, LastSFP->domega2);
for(int k = 1; k<=(int)(QP_T_/m_SamplingPeriod);k++)
{
if (CurrentSupport.Foot == LEFT)
{
UpdateFootPosition(FinalLeftFootTraj_deq,
FinalRightFootTraj_deq,
CurrentIndex,k,
LocalInterpolationStartTime,
UnlockedSwingPeriod,
StepType, -1);
}
else
{
UpdateFootPosition(FinalRightFootTraj_deq,
FinalLeftFootTraj_deq,
CurrentIndex,k,
LocalInterpolationStartTime,
UnlockedSwingPeriod,
StepType, 1);
}
FinalLeftFootTraj_deq[CurrentIndex+k].time =
FinalRightFootTraj_deq[CurrentIndex+k].time = Time+k*m_SamplingPeriod;
}
}
else if (CurrentSupport.Phase == DS || Time+3.0/2.0*QP_T_ > CurrentSupport.TimeLimit)
{
for(int k = 1; k<=(int)(QP_T_/m_SamplingPeriod);k++)
{
FinalRightFootTraj_deq[CurrentIndex+k] = FinalRightFootTraj_deq[CurrentIndex+k-1];
FinalLeftFootTraj_deq [CurrentIndex+k] = FinalLeftFootTraj_deq [CurrentIndex+k-1];
FinalLeftFootTraj_deq [CurrentIndex+k].dx = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].dy = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].dz = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].domega = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].domega2 = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].dtheta = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddx = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddy = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddz = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddomega = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddomega2 = 0.0 ;
FinalLeftFootTraj_deq [CurrentIndex+k].ddtheta = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].dx = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].dy = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].dz = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].domega = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].domega2 = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].dtheta = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddx = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddy = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddz = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddomega = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddomega2 = 0.0 ;
FinalRightFootTraj_deq [CurrentIndex+k].ddtheta = 0.0 ;
FinalLeftFootTraj_deq[CurrentIndex+k].time =
FinalRightFootTraj_deq[CurrentIndex+k].time = Time+k*m_SamplingPeriod;
FinalLeftFootTraj_deq[CurrentIndex+k].stepType =
FinalRightFootTraj_deq[CurrentIndex+k].stepType = 10;
}
}
}
void CuePack::DumpCue(const string& dir, Cd* cd, deque<MediaItem>& list) const
{
int ntrack = cd_get_ntrack(cd);
string album;
string artist;
string genre;
int year = -1;
char* data = nullptr;
Cdtext* cdt = cd_get_cdtext(cd);
Rem* rem = cd_get_rem(cd);
data = cdtext_get(PTI_TITLE, cdt);
if (data != nullptr) {
album = data;
delete data;
}
data = cdtext_get(PTI_PERFORMER, cdt);
if (data != nullptr) {
artist = data;
delete data;
}
data = cdtext_get(PTI_GENRE, cdt);
if (data != nullptr) {
genre = data;
delete data;
}
//cdtext_delete(cdt);
//rem_free(rem);
data = rem_get(REM_DATE, rem);
if (data != nullptr) {
year = StrToNum<int>(data);
delete data;
}
list.resize(ntrack);
for (int i = 1; i <= ntrack; ++i) {
MediaItem& item = list[i-1];
Track* track = cd_get_track(cd, i);
item.url = dir + track_get_filename(track);
item.hasRange = true;
//item->msBeg = (track_get_start(track))/75*1000;
//item->msEnd = item->msBeg + ((uint64_t)track_get_length(track))/75*1000;
item.msBeg = ((track_get_start(track)
//+ track_get_index(track, 1)
- track_get_zero_pre(track)) * 1000) / 75;
item.msEnd = ((track_get_start(track) + track_get_length(track)
//- track_get_index(track, 1)
+ track_get_zero_pre(track)) * 1000) / 75;
if (item.msBeg >= item.msEnd || i == ntrack)
item.msEnd = -1;
Cdtext* text = track_get_cdtext(track);
item.tag.album = album;
item.tag.year = year;
data = cdtext_get(PTI_TITLE, text);
if (data != nullptr) {
item.tag.title = data;
delete data;
}
data = cdtext_get(PTI_PERFORMER, text);
if (data != nullptr) {
item.tag.artist = data;
delete data;
} else {
item.tag.artist = artist;
}
data = cdtext_get(PTI_GENRE, text);
if (data != nullptr) {
item.tag.genre = data;
delete data;
} else {
item.tag.genre = genre;
}
item.tag.track = i;
//cdtext_delete(text);
}
}
ReturnCode_t onActivateted(UniqueId ec_id)
{
timedTbuf.clear();
timedTbuf.resize(BUF_SIZE);
}
void redimTbl(unsigned int nb)
{
msgs.resize(nb);
initialiser();
}
void reinitialiser()
{
msgs.resize(0);
}
deque<deque<int>> center_mat(deque<deque<int>> src_mat){
deque<deque<int>> t_mat;
deque<int> vec_zero;
int marge_gauche=0;
int marge_droite=0;
int marge_haut=0;
int marge_bas=0;
int delta_x = 0;
int delta_y = 0;
int temp_size;
bool stop;
stop = false;
//Marge Gauche
for(int i=0;i<src_mat.size();i++){
for(int j=0;j<src_mat[i].size();j++){
if(!stop && src_mat[j][i]){
marge_gauche = i;
stop = true;
}
}
}
stop = false;
//Marge Droite
for(int i=src_mat.size()-1;i>=0;i--){
for(int j=0;j<src_mat[i].size();j++){
if(!stop && src_mat[j][i]){
marge_droite = src_mat.size()-i;
stop = true;
}
}
}
stop = false;
//Marge Haut
for(int i=0;i<src_mat.size();i++){
for(int j=0;j<src_mat[i].size();j++){
if(!stop && src_mat[i][j]){
marge_haut = i;
stop = true;
}
}
}
stop = false;
//Marge Bas
for(int i=src_mat.size()-1;i>=0;i--){
for(int j=0;j<src_mat[i].size();j++){
if(!stop && src_mat[i][j]){
marge_bas = src_mat.size()-i;
stop = true;
}
}
}
delta_x = (marge_droite-marge_gauche)/2;
delta_y = (marge_bas-marge_haut)/2;
cout << delta_x << endl;
cout << delta_y << endl;
vec_zero.resize(src_mat.size());
temp_size = src_mat.size();
// Lignes de zeros
if(delta_y>0){
for(int i=0;i<delta_y;i++){
src_mat.push_front(vec_zero);
}
src_mat.resize(temp_size);
}else{
for(int i=0;i<-delta_y+1;i++){
src_mat.push_back(vec_zero);
}
src_mat.erase(src_mat.begin(),src_mat.begin()-delta_y);
}
// Colonnes de zeros
if(delta_x>0){
for (int i=0; i<src_mat.size(); i++){
for(int j=0;j<delta_x;j++){
src_mat[i].push_front(0);
}
src_mat[i].resize(temp_size);
}
}else{
for (int i=0; i<src_mat.size(); i++){
for(int j=0;j<-delta_x+1;j++){
src_mat[i].push_back(0);
src_mat[i].erase(src_mat[i].begin());
}
}
}
return src_mat;
}
