void basic_algo(){
cout<<endl<<"basic_algo :"<<endl;
int ia[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8 };
vector<int> iv1(ia,ia+5); vector<int> iv2(ia,ia+9);
cout<<iv1<<endl<<iv2<<endl;
pair<vector<int>::iterator,vector<int>::iterator> p = mismatch(iv1.begin(),iv1.end(),iv2.begin()); //返回在游标的哪个位置不匹配
if(p.first != iv1.end()) cout<<*(p.first)<<endl;
if(p.second != iv2.end()) cout<<*(p.second)<<endl;
cout<<equal(iv1.begin(),iv1.end(),iv2.begin())<<endl; //比较容器内内容
cout<<equal(iv1.begin(),iv1.end(),&ia[3])<<endl;
cout<<equal(iv1.begin(),iv1.end(),&ia[3],less<int>())<<endl;
fill(iv1.begin(),iv1.end(),9); //区间填充
cout<<iv1<<endl;
fill_n(iv1.begin(), 3, 7); //区间n填充
cout<<iv1<<endl;
vector<int>::iterator iter1,iter2;
iter1 = iter2 = iv1.begin();
advance(iter2,3); //游标向前移动
iter_swap(iter1,iter2); //交换两个游标内容
cout<<iv1<<endl;
swap(*iv1.begin(),*iv2.begin()); //交换两个游标内容
cout<<iv1<<endl<<iv2<<endl;
string stra1[] = {"jk","jK1","jk2"}; string stra2[] = {"jk","jk1","jk3"};
cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2)<<endl;
cout<<lexicographical_compare(stra1,stra1+2,stra2,stra2+2,greater<string>())<<endl;
copy(iv2.begin()+1,iv2.end(),iv2.begin()); //全部元素向前移一格
cout<<iv2<<endl;
copy_backward(iv2.begin(),iv2.end()-1,iv2.end()); //全部元素向后移一格
cout<<iv2<<endl;
}
void quickSort(vector<int> &v, int start, int end){
if(start>=end)
return;
srand (time(NULL));
int pivot = rand()%(end-start+1)+start;
iter_swap(v.begin()+start,v.begin()+pivot);
int i=start+1;
int j=i;
for(;i<=end&&j<=end;){
if(compare(v[start],v[j]))
{
j++;
} else{
iter_swap(v.begin()+i,v.begin()+j);
i++;
j++;
}
}
iter_swap(v.begin()+start,v.begin()+i-1);
quickSort(v,start,i-2);
quickSort(v,i,end);
}
void sortFollowerWithMaster(vector<int>::iterator m_b,
vector<int>::iterator m_e, vector<int>::iterator f_b,
vector<int>::iterator f_e) {
// masterとfollowerのサイズが一致するかチェック
if (distance(m_b, m_e) != distance(f_b, f_e)) {
cerr << "Error: Length of master and follower must be the same."
<< endl;
exit(1);
}
// 再帰の終了条件
if (distance(m_b, m_e) <= 1) {
return;
}
vector<int>::iterator m_l = m_b;
vector<int>::iterator m_r = m_e - 1;
vector<int>::iterator f_l = f_b;
vector<int>::iterator f_r = f_e - 1;
int pivot = *m_r;
/*
処理の本体。
masterとfollowerを一緒に更新していくので、
インクリメントやディクリメントの処理がペアになっている。
*/
while (distance(m_l, m_r) > 0) {
while (distance(m_l, m_r) > 0 && *m_l < pivot) {
++m_l;
++f_l;
}
if (distance(m_l, m_r) == 0) {
break;
}
while (distance(m_l, m_r) > 0 && pivot <= *m_r) {
--m_r;
--f_r;
}
if (distance(m_l, m_r) == 0) {
break;
}
iter_swap(m_l, m_r);
iter_swap(f_l, f_r);
}
iter_swap(m_l, m_e - 1);
iter_swap(f_l, f_e - 1);
// 再帰
sortFollowerWithMaster(m_b, m_l, f_b, f_l);
sortFollowerWithMaster(m_l + 1, m_e, f_l + 1, f_e);
}
// b points one element beyond the last element be reversing
void reverse(uint8_t *a, uint8_t *b)
{
b--; // point b to element to begin reversing
if (a < b)
{
while(a < b)
iter_swap(a++, b--);
}
else
{
while(b < a)
iter_swap(b++, a--);
}
}
/**
* \brief Imprime todas as informações dos serviços do vetor
* \return Esta função não possui retorno
*/
void Empresa::printServicos()
{
/*Algoritmo para ordenar o vetor por ordem crescente do código identificador.
Foi feito depois do Doxygen, pelo que não é um função à parte.
Mecanismo Bubblesort.*/
int n = this->servicos.size();
while (1)
{
bool swap = false;
for (int i = 1; i < n; i++)
{
if (servicos[i - 1]->getId() > servicos[i]->getId())
{
iter_swap(servicos.begin() + i - 1, servicos.begin() + i);
swap = true;
}
}
n--;
if (!swap)
break;
}
cout << "SERVICOS" << endl << endl;
cout << setw(4) << "ID" << setw(18) << "Preco (euros)" << setw(19) << "Distancia (km)" << setw(9) << "Status" << endl;
for (unsigned int i = 0; i < this->servicos.size(); i++)
{
cout << setw(4) << this->servicos[i]->getId() << setw(18) << this->servicos[i]->getPreco() << setw(19) << this->servicos[i]->getDistancia() << setw(9) << this->servicos[i]->printStatus() << endl;
}
}
BOOL next_permutation(uint8_t *first, uint8_t *last)
{
uint8_t *i = last - 1;;
if( first == last ) // check for n=0
return FALSE;
if( first == i ) // check for n=1
return FALSE;
for(;;)
{
uint8_t *ii = i--;
if (*i < *ii)
{
uint8_t *j = last;
while( !(*i < *--j) ) ;
iter_swap(i, j);
reverse(ii, last);
return TRUE;
}
if (i == first)
{
reverse(first, last);
return FALSE;
}
}
}
void Comparator::prepareTrees(){
vector <vector<vector <Dir> > >::iterator it;
vector<Dir> temp;
vector<Dir>::iterator fIt;
int i = 0,k=0,j;
vector<vector <Dir> > currentFS;
for(i = 0; i<k; i++){
j=0;
string path ="";
for(string d : vcurrentTPath[k]){
if(d[0]!='/')
path = path +"/"+ d;
}
for(string majName : majorityChildren){
majName = majName.substr(majName.find_last_of("/")+1);
cout<<"majname = "<<majName<<endl;
for(fIt = (*(vfileSystem[i].end()-1)).begin(); fIt!= (*(vfileSystem[i].end()-1)).end(); fIt++){
if((*fIt).name == majName){
cout<<"found"<<endl;
iter_swap((*(vfileSystem[i].end()-1)).begin()+j, fIt);
j++;
break;
}
}
}
}
}
bool prev_permutation(BidirIt first, BidirIt last) noexcept
{
if (first == last)
return false;
auto i = last;
if (first == --i)
return false;
while (true) {
BidirIt i1, i2;
i1 = i;
if (*i1 < *--i) {
i2 = last;
while (!(*--i2 < *i))
;
iter_swap(i, i2);
reverse(i1, last);
return true;
}
if (i == first) {
reverse(first, last);
return false;
}
}
}
static void
dict_list_down_clicked_cb (GtkButton *button,
gpointer userdata)
{
GtkTreeView *view = GTK_TREE_VIEW(userdata);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
GtkTreePath *path;
GtkTreeIter next_iter;
int i;
path = gtk_tree_model_get_path(model, &iter);
i = gtk_tree_path_get_indices(path)[0];
if (i < __config_sysdicts.size() - 1) {
vector<String>::iterator it = __config_sysdicts.begin() + i;
vector<String>::iterator it2 = it + 1;
iter_swap(it, it2);
__have_changed = true;
}
gtk_tree_path_next(path);
if (gtk_tree_model_get_iter(model, &next_iter, path)) {
gtk_list_store_move_after(GTK_LIST_STORE(model),
&iter, &next_iter);
}
gtk_tree_path_free(path);
}
}
DECLARE_EXPORT const Demand::OperationPlanList& Demand::getDelivery() const
{
// We need to check the sorting order of the list first! It could be disturbed
// when operationplans are being moved around.
// The sorting routine isn't very efficient, but should suffice since the
// list of delivery operationplans is short and isn't expected to be
// disturbed very often.
for (bool swapped(!deli.empty()); swapped; swapped=false)
{
OperationPlanList::iterator j = const_cast<Demand*>(this)->deli.begin();
++j;
for (OperationPlanList::iterator i =
const_cast<Demand*>(this)->deli.begin();
j!=const_cast<Demand*>(this)->deli.end(); ++j)
{
if ((*i)->getDates().getEnd() < (*j)->getDates().getEnd())
{
// Oh yes, the ordering was disrupted indeed...
iter_swap(i,j);
swapped = true;
break;
}
++i;
}
}
return deli;
}
/**
* @param nums: A list of integers
* @return: A list of integers
*/
vector<int> nextPermutation(vector<int> &nums) {
// write your code here
vector<int>::iterator first = nums.begin(), last = nums.end();
if(first == last)
return nums;
vector<int>::iterator i = last;
if(first == --i)
return nums;
while(true)
{
vector<int>::iterator l1 = i;
if(*--i < *l1)
{
vector<int>::iterator l2 = last;
while(*i >= *--l2)
;
iter_swap(i, l2);
reverse(l1, last);
return nums;
}
if(i == first)
{
reverse(first, last);
return nums;
}
}
}
bool next_permutation(BidirIt first, BidirIt last, Compare compare) noexcept
{
if (first == last)
return false;
auto i = first;
if (++i == last)
return false;
i = last;
--i;
while (true) {
auto __ii = i;
--i;
if (compare(*i, *__ii)) {
auto __j = last;
while (!compare(*i, *(--__j)))
;
iter_swap(i, __j);
reverse(__ii, last);
return true;
}
if (i == first) {
reverse(first, last);
return false;
}
}
}
void
remove_edge_if(Predicate p,
std::vector<EdgeList, Allocator>& g)
{
for (std::size_t u = 0; u < g.size(); ++u) {
// Oops! gcc gets internal compiler error on compose_.......
typedef typename EdgeList::iterator iterator;
iterator b = g[u].begin(), e = g[u].end();
if (!g[u].empty()) {
for(; b != e;) {
if (p(std::make_pair(u, *b))) {
--e;
if (b == e)
break;
else
iter_swap(b, e);
} else {
++b;
}
}
}
if (e != g[u].end())
g[u].erase(e, g[u].end());
}
}
bool next_permutation(BidirIt first, BidirIt last) noexcept
{
if (first == last || first == (last - 1))
return false;
auto i = last - 1;
while (true) {
auto __ii = i;
--i;
if (*i < *__ii) {
auto __j = last;
while (!(*i < *--__j))
;
iter_swap(i, __j);
reverse(__ii, last);
return true;
}
if (i == first) {
reverse(first, last);
return false;
}
}
}
sf::ConvexShape ConvexHull(vector<sf::Vector2f> Points)
{
iter_swap(Points.begin(), min_element(Points.begin(), Points.end(), BottomLeftComp));
AngleCompare AngleComp(Points.front());
sort(Points.begin() + 1, Points.end(), AngleComp);
int m = 0;
for (unsigned int i = 1; i < Points.size(); i++)
{
while (CCW(Points[m == 0 ? Points.size() - 1 : m - 1], Points[m], Points[i]) >= 0.f)
{
if (m > 0)
m--;
else if (i == Points.size() - 1)
break;
else
i++;
}
m++;
swap(Points[m], Points[i]);
}
sf::ConvexShape Shape(m + 1);
for (unsigned int i = 0; i < Shape.getPointCount(); i++)
Shape.setPoint(i, Points[i]);
return Shape;
}
template<class Iterator> void bubblesort(Iterator start, Iterator end) {
Iterator curr = start;
bool count_iteration = true;
int n = 2;
for (bool swapped = true; swapped && n > 1; ) {
if (count_iteration)
n = 0;
swapped = false;
for(; curr != end; ) {
if (count_iteration)
n++;
Iterator prev = curr;
++curr;
if(curr == end) break;
if( *prev > *curr ) {
iter_swap(prev, curr);
swapped = true;
}
}
curr = start;
--n;
count_iteration = false;
}
}
static void RandInts(
vec_int& ints, // out: scrambled integers in range 0 ... NSIZE(ints)-1
int seed) // in: random seed
{
const int n = NSIZE(ints);
CV_Assert(n > 0);
if (n > RAND_MAX)
Err("vector size %d is too big (max allowed is %d)", n, RAND_MAX);
CV_Assert(seed != 0);
if (seed == 1) // 1 has a special meaning which we don't want
seed = int(1e6); // arb
int i;
for (i = 0; i < n; i++)
ints[i] = i;
srand(seed);
// We use our own random shuffle here because different compilers
// give different results which messes up regression testing.
// (I think only Visual C 6.0 is incompatible with everyone else?)
//
// Following code is equivalent to
// random_shuffle(ints.begin(), ints.end(),
// pointer_to_unary_function<int,int>(RandInt));
vec_int::iterator it = ints.begin();
for (i = 2; ++it != ints.end(); i++)
iter_swap(it, ints.begin() + rand() % n);
}
/*pourrir la vie de l’adversaire* : utiliser au maximum les attaques et avancer des que l’adversaire est bloque.*/
void JoueurPourrir::choisirCarte(std::vector<Carte*> tasAdv, std::vector<Carte*> defausse){
bool tag = true; //permet d'éviter de jouer plusieurs fois en un tour
for (int i=0; i<main.size(); i++){ //on essaie de jouer une parade, car c'est la priorité.
if (estJouable(main.at(i), tasAdv.back()) && main.at(i)->getType() == "Parade" && tag){
tas.push_back(main.at(i));
iter_swap(main.begin() + i, main.end());
main.pop_back();
tag = false;
}
}
if(tag){ //si on n'a pas encore joué
for (int i=0; i<main.size(); i++){
if (estJouable(main.at(i), tasAdv.back()) && main.at(i)->getType() == "Attaque" && tag){
tasAdv.push_back(main.at(i));
iter_swap(main.begin() + i, main.end());
main.pop_back();
tag = false;
}
}
}
if(tag){ //si on n'a toujours pas joué
for (int i=0; i<main.size(); i++){
if (estJouable(main.at(i), tasAdv.back()) && main.at(i)->getType() == "Point" && tag){
tas.push_back(main.at(i));
iter_swap(main.begin() + i, main.end());
main.pop_back();
tag = false;
}
}
}
if (tag){ //si à la fin on a pas joué, on doit se défausser d'une carte
for (int i=0; i<main.size(); i++){
if (main.at(i)->getType() == "Point"){
defausse.push_back(main.at(i));
iter_swap(main.begin() + i, main.end());
main.pop_back();
}
}
}
//elseif carte parade dans la main && mon tas == carte attaque && mon tas == carte attaque
//if groupe(carteparade) == groupe(carteattaque)
//se débloquer
//else se défausser
//else se défausser
}
void Layer::setLayerIndex(int index)
{
vector<Layer*> &layers = manager->layers;
if (index < 0 || index >= layers.size()) return;
vector<Layer*>::iterator it = layers.begin();
iter_swap(it + layer_index, it + index);
}
void randomPerms(D& arr, randEngine& mtRandom)
{
typedef typename D::iterator iter;
randInt sample(mtRandom, intUniformDist(0,arr.size()-1));
for (iter it=arr.begin(); it!=arr.end(); ++it)
iter_swap(arr.begin()+sample(),it);
} // randomPerms
void EventHandle::OrderInput() // If input has moved around in the vector, re-orders it to match
{
for (int i = 0; i < m_vKeys.size(); ++i)
{
for (int j = 0; j < m_vPrevKeys.size(); ++j)
{
if ((i < m_vPrevKeys.size()) && (m_vKeys[i] == m_vPrevKeys[j]))
{
iter_swap(m_vPrevKeys.begin() + i, m_vPrevKeys.begin() + j);
iter_swap(m_vUntilRepeat.begin() + i, m_vUntilRepeat.begin() + j);
iter_swap(m_vUntilPressed.begin() + i, m_vUntilPressed.begin() + j);
}
else if ((j < m_vKeys.size()) && (m_vKeys[i] == m_vPrevKeys[j]))
iter_swap(m_vKeys.begin() + i, m_vKeys.begin() + j);
}
}
}
void swappable_iterator_test(Iterator i, Iterator j)
{
Iterator i2(i), j2(j);
typename detail::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
iter_swap(i2, j2);
typename detail::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
assert(bi == aj && bj == ai);
}
vector<int> slashBurn(Graph &graph, int K)
{
//printGraph(graph);
int p = 0, q = (int)graph.size() - 1;
vector<int> weightsum(q + 1, 0);
vector<int> idX(q + 1, 0), xId(q + 1, 0);
for(int i = 0; i < q + 1; i++){
idX[i] = xId[i] = i;
}
calcWeightSum(weightsum, graph);
while(q - p + 1 > K){
if(TKDE){
/* TKDE: select topK in greedy way */
for(int i = 0; i < K; i++, p++){
int maxloc = select_biggest(weightsum, xId, p, q);
remove_vertex_from_graph(graph, xId[maxloc], weightsum);
iter_swap(idX.begin() + xId[p], idX.begin() + xId[maxloc]);
iter_swap(xId.begin() + maxloc, xId.begin() + p);
}
}
else{
/* ICDM: select topK directly */
vector<int> maxloc = select_topk(weightsum, xId, p, q, K);
for(vector<int>::iterator it = maxloc.begin(); it != maxloc.end(); ++it, p++){
remove_vertex_from_graph(graph, xId[*it], weightsum);
iter_swap(idX.begin() + xId[p], idX.begin() + xId[*it]);
iter_swap(xId.begin() + *it, xId.begin() + p);
}
}
//Map or vector, trade-off between space and time
vector<int> vertexCC(graph.size(), 0);
vector<pair<int, int> > ccMetric(graph.size());
find_cc(graph, p, q, xId, idX, vertexCC, ccMetric);
vector<int> newx2X;
int Q = sort_vertex(newx2X, vertexCC, ccMetric);
if(Q == -1){
break;
}
for(int i = Q; i < (int)newx2X.size(); i++){
remove_vertex_from_graph(graph, xId[newx2X[i]], weightsum);
}
shuffle_vertex(newx2X, xId, idX, p);
q = p + Q - 1;
}
return idX;
}
void sortFollowerWithMaster(vector<vector<int> >::iterator m_b,
vector<vector<int> >::iterator m_e, vector<int>::iterator f_b,
vector<int>::iterator f_e) {
if (distance(m_b, m_e) != distance(f_b, f_e)) {
cerr << "Error: Length of master and follower must be the same."
<< endl;
exit(1);
}
if (distance(m_b, m_e) <= 1) {
return;
}
vector<vector<int> >::iterator m_l = m_b;
vector<vector<int> >::iterator m_r = m_e - 1;
vector<int>::iterator f_l = f_b;
vector<int>::iterator f_r = f_e - 1;
vector<int> pivot = *m_r;
while (distance(m_l, m_r) > 0) {
while (distance(m_l, m_r) > 0 && *m_l < pivot) {
++m_l;
++f_l;
}
if (distance(m_l, m_r) == 0) {
break;
}
while (distance(m_l, m_r) > 0 && pivot <= *m_r) {
--m_r;
--f_r;
}
if (distance(m_l, m_r) == 0) {
break;
}
iter_swap(m_l, m_r);
iter_swap(f_l, f_r);
}
iter_swap(m_l, m_e - 1);
iter_swap(f_l, f_e - 1);
sortFollowerWithMaster(m_b, m_l, f_b, f_l);
sortFollowerWithMaster(m_l + 1, m_e, f_l + 1, f_e);
}
void select_sort(iterator begin, iterator end) {
for (iterator round=begin; round<end-1; ++round) {
iterator min=round;
for (iterator it=round+1; it<end; ++it)
if (*it<*min) min=it;
iter_swap(round, min);
}
}
template <class ZT, class FT> void MatHouseholder<ZT, FT>::swap(int i, int j)
{
FPLLL_DEBUG_CHECK(0 <= i && i < j && j < d);
// Invalidate to the min not modified row, that is i
invalidate_row(i);
b.swap_rows(i, j);
bf.swap_rows(i, j);
iter_swap(sigma.begin() + i, sigma.begin() + j);
if (enable_row_expo)
iter_swap(row_expo.begin() + i, row_expo.begin() + j);
iter_swap(init_row_size.begin() + i, init_row_size.begin() + j);
iter_swap(R_history.begin() + i, R_history.begin() + j);
if (enable_transform)
{
u.swap_rows(i, j);
if (enable_inverse_transform)
u_inv_t.swap_rows(i, j);
}
iter_swap(norm_square_b.begin() + i, norm_square_b.begin() + j);
iter_swap(expo_norm_square_b.begin() + i, expo_norm_square_b.begin() + j);
#ifdef DEBUG
iter_swap(col_kept.begin() + i, col_kept.begin() + j);
#endif // DEBUG
}
vector<City> Agent::hillClimb(vector<City> cities) {
City start_city = cities[0];
vector<City> journeyPath;
journeyPath.push_back(cities[0]);
double min;
int minIndex;
double totalDistance = 0;
while (cities.size() != 1) {
if (shortestDistance != 0 && totalDistance > shortestDistance) {
return shortestRoute;
}
min = calculateDistance(cities[0].get_x(), cities[0].get_y(),
cities[1].get_x(), cities[1].get_y());
minIndex = 1;
for (std::vector<City>::iterator it = cities.begin() + 2;
it != cities.end(); ++it) {
double distance = calculateDistance(cities[0].get_x(),
cities[0].get_y(), (*it).get_x(), (*it).get_y());
if (distance < min) {
min = distance;
minIndex = it - cities.begin();
}
}
totalDistance += min;
iter_swap(cities.begin(), cities.begin() + minIndex);
journeyPath.push_back(cities[0]);
cities.erase(cities.begin() + minIndex);
}
double lastDistance = abs(
(journeyPath.back().get_x() - cities[0].get_x())
+ (journeyPath.back().get_y() - cities[0].get_y()));
cities.erase(cities.begin());
totalDistance += lastDistance;
double distanceBackToInitial = abs(
(journeyPath.back().get_x() - journeyPath[0].get_x())
+ (journeyPath.back().get_y() - journeyPath[0].get_y()));
journeyPath.push_back(journeyPath[0]);
totalDistance += distanceBackToInitial;
if (shortestDistance != 0 && totalDistance > shortestDistance) {
return shortestRoute;
} else {
shortestRoute = journeyPath;
shortestDistance = totalDistance;
}
return shortestRoute;
}
//Swaps item at index _a with item at index _b
void swap(long _a, long _b)
{
if(_a == _b) return;
//Store entry pointed to by the id of _a
slot swap = {_a, m_ids[_b].m_version};
//Make the entry at _a's id point to _a's future index.
m_indirection[ m_ids[_a].m_id ] = {_b, m_ids[_a].m_version};
//Make the entry at _b's id point to _b's future index.
m_indirection[ m_ids[_b].m_id ] = swap;
//std::swap( m_objects[_a], m_objects[_b] );
//std::swap( m_ids[_a], m_ids[_b] );
iter_swap( m_objects.begin() + _a, m_objects.begin() + _b );
iter_swap( m_ids.begin() + _a, m_ids.begin() + _b );
}
ForwardIt1 swap_ranges(ForwardIt1 first, ForwardIt1 last, ForwardIt2 first2) noexcept
{
while (first != last) {
iter_swap(first, first2);
++first;
++first2;
}
return first2;
}
int main ()
{
vector <int> v1 (6);
iota (v1.begin (), v1.end (), 0);
iter_swap (v1.begin (), v1.begin () + 3);
ostream_iterator <int> iter (cout, " ");
copy (v1.begin (), v1.end (), iter);
cout << endl;
return 0;
}
