algorithm and data-structure

新人クンにC++を教えてやってくれ。二日で。

επιστημη — Tue, 28 Aug 2012 17:06:00 GMT

いや無理。それは無理。
二日で教えられるもんなら四半世紀やってきた僕の立つ瀬がねっす。

「そこをなんとか、サワリのとこだけでも」ってことやったんで
ちょーキホンなクラスの書き方とか教えてやることに。

新人クン、Cはそこそこ書けるみたいなんで
C++文法/構文をざっくり流して演習問題:

「intを要素とする可変長配列Vectorおよび
　末尾に追加するadd(int val)を実装してみそ？」

彼の書いたコード:

class Vector {
int* data; // 配列本体
int index; // 次にaddする位置(=要素数)
int capacity; // dataの容量
public:
Vector(int cap);
~Vector();
bool add(int val);
};

Vector::Vector(int cap) {
capacity = cap;
data = new int[capacity];
index = 0;
}

Vector::~Vector() {
delete[] data;
}

bool Vector::add(int val) {
if ( index >= capacity ) return false; // 容量オーバー
index++;
data[index] = val;
return true;
}

...おぅ、けっこー書けてんじゃん...おんや?
「おーい、バグってんよ？」
「え！？どこっスか？」
「ほらココ。Vector::addでdata[0]が空席になってる」
「ホントだー。すぐ直しますっ」

３分後

Vector::Vector(int cap) {
capacity = cap;
data = new int[capacity];
index = -1;
}

ばっかやろーー!!!

渡る者の途絶えた橋 (C#/LINQ版)

επιστημη — Fri, 28 Jan 2011 22:58:00 GMT

えとー、こんなもんかの。

#define SET_3

using System;
using System.Collections.Generic;
using System.Linq;

namespace DAG {
struct bridge {
    public char fr;
    public char to;
    public bridge(char f, char t) { fr = f; to = t; }
}

class Program
{
      static void Main() {
      List<bridge> path = new List<bridge>
#if SET_1
      {
        new bridge('A','B'),
        new bridge('B','C'),
        new bridge('A','C'),
        new bridge('A','D'),
        new bridge('C','D'),
      };
#elif SET_2
      {
        new bridge('A','B'),
        new bridge('A','C'),
        new bridge('B','C'),
        new bridge('B','D'),
        new bridge('D','A'),
        new bridge('D','C'),
      };
#elif SET_3
      {
        new bridge('A','B'),
        new bridge('B','C'),
        new bridge('C','D'),
        new bridge('D','E'),
        new bridge('E','F'),
        new bridge('F','G'),
        new bridge('G','H'),
        new bridge('H','F'),
      };
#endif
      while ( true ) {
        // 表示
        path.ForEach(item => Console.WriteLine("{0}->{1}", item.fr, item.to));
        Console.WriteLine();
        // 入口/出口セットを作る
        var froms = (from item in path select item.fr).Distinct();
        var tos   = (from item in path select item.to).Distinct();
        // 入口/出口セットの一方にあって他方にないものをremoveに
        // symmetrc-diference に相当するもんがなさげなんで"X-Y と Y-X の和集合"で代用
　　　　 var remove = Enumerable.Union(froms.Except(tos), tos.Except(froms));
        if ( remove.Count() == 0 ) break;
        // removeに含まれない橋を抽出する
        path = (from item in path
                where !(remove.Contains(item.fr) || remove.Contains(item.to))
                select item).ToList();
      }
      Console.WriteLine(path.Count() == 0 ? "DAG!!" : "cyclic!!");
    }
}
}

渡る者の途絶えた橋

επιστημη — Thu, 20 Jan 2011 21:12:00 GMT

数学屋さんは「いくつかの島に橋が架かった様子」をグラフ(Graph)といいます。

グラフのバリエーションとして、島に架かる橋が一方通行であるものを有向グラフ(Directed Graph)と称しております。

さらに有向グラフは大きく二つに分類されます。
ある島から一方通行の橋を渡っていけば元の島に戻れる経路のあるものを「閉路(cycle)のある有向グラフ」、
それと閉路のひとつもない「無閉路有向グラフ:DAG(Directed Acyclic Graph)」です。

DAGはエンジニアリングの分野と深い関わりがあります。
たとえばC/C++での#include関係はDAGになってますし、
.NETだとアセンブリの参照関係もDAGです。
クラスの継承もDAGですな。
あるいはお料理のレシピやmakefileなどの「手順書」もDAGです。
手順書がDAGでないと作業の堂々巡りが存在するわけで、いつまでたっても完了できひんです。

さて、とある有向グラフが与えられたとき、それがDAGであるか否かを判定するアルゴリズムを考えます。

[1] まず、有向グラフのデータとして橋の集合を用意します。橋には方向があるので"入口の島"→"出口の島"でひとつの橋を表現します。サンプルはコレ:

このグラフに引かれた矢印(つまり橋)を列挙すると:

A→B
A→C
B→C
C→D

の４本の橋が架かっています。

[2] 橋の入口を持つ島の集合を Iin, 出口を持つ島の集合をIoutとすると、
Iin = { A, B, C }, Iout = { B, C, D }
ですわね。ここで
Iin に含まれるが Iout に含まれない島の集合は { A }、
Iout に含まれるが Iin に含まれない島の集合は { D } です。
それぞれ入ることのできない島/出ることのできない島の集合です。
こんな島は閉路の通り道にはなり得ません。閉路の通り道になるなら必ず入る橋と出る橋がそれぞれ一つ以上架かっているでしょうから。
そんなわけで、閉路の通り道となり得ない島(入れない島と出られない島)に架かる橋を取り除きます。

B→C

が残りました。

[3] 上の手順を繰り返します。
Iin = { B }, Iout ={ C }
ですから、このいずれかに架かる橋を取り除くと橋がなくなってしまいます。
閉路を構成する可能性のある橋がなくなった、てことは DAG です。

同じことを

こいつでやってみましょ。

A→B
B→C
C→A
C→D

ですから、
Iin = { A, B ,C }, Iout = { A, B , C, D }
IinとIoutのどちらかにしか含まれない島の集合は { D }、
{ D } に架かる橋を取り除くと:

A→B
B→C
C→A

もう一度。
Iin = { A, B, C }, Iout = { A, B, C }
どちらかにしか含まれない島はありません。Φ(空集合)です。
なのでこれ以上取り除ける橋はありません。
なのにまだ橋が残っています。なので DAG ではありません。

…んじゃまそゆことで、さくさくーっと実装してやんよ。

#include <iostream>

#include <algorithm>

#include <iterator>

#include <utility>

#include <set>

#include <vector>

using namespace std;

int main() {

typedef pair<char,char> dep;

vector<dep> deps;

#if 0

deps.push_back(dep('A','B'));

deps.push_back(dep('B','C'));

deps.push_back(dep('A','C'));

deps.push_back(dep('A','D'));

deps.push_back(dep('C','D'));

#elif 0

deps.push_back(dep('A','B'));

deps.push_back(dep('A','C'));

deps.push_back(dep('B','C'));

deps.push_back(dep('B','D'));

deps.push_back(dep('D','A'));

deps.push_back(dep('D','C'));

#elif 1

deps.push_back(dep('A','B'));

deps.push_back(dep('B','C'));

deps.push_back(dep('C','D'));

deps.push_back(dep('D','E'));

deps.push_back(dep('E','F'));

deps.push_back(dep('F','G'));

deps.push_back(dep('G','H'));

deps.push_back(dep('H','F'));

#endif

while ( true ) {

// 表示

for_each(deps.begin(), deps.end(),

[&](const dep& x) {

cout << x.first << "->" << x.second << endl;

});

cout << endl;

// 入口/出口セットを作る

set<char> parent;

set<char> child;

for_each(deps.begin(), deps.end(),

[&](const dep& x) {

parent.insert(x.first);

child.insert(x.second);

});

// 入口/出口セットの一方にあって他方にないものをdifに

vector<char> dif;

set_symmetric_difference(parent.begin(), parent.end(),

child.begin(), child.end(),

back_inserter(dif));

if ( dif.empty() ) break;

// 入口/出口のいずれかがdifにあればそれを削除

vector<dep>::iterator last = deps.end();

for_each(dif.begin(), dif.end(),

[&](char ch) {

last = remove_if(deps.begin(), last,

[=](const dep& x) {

return x.first == ch || x.second == ch;

});

deps.erase(last, deps.end());

}

if ( deps.empty() ) {

cout << "DAG!!" << endl;

} else {

cout << "cyclic!!" << endl;

}

あー、だれぞC#/VBにportしてはくれんかのぅ...

昆布じゃないのよ(そのに)

επιστημη — Wed, 29 Dec 2010 01:33:00 GMT

先日の combsort 、比較/交換する要素間の距離(gap)をぢわぢわ縮めていく
bubblesort の改良版なわけですが。

どのくらいずつ縮めていくか、つまり gap = gap / ratio; における ratio は
実験的に 1.3 だという。ホントかしら? ってんでやってみた。

template<typename Iterator>
void combsort(Iterator first, Iterator last, double gap_ratio) {
auto gap = std::distance(first,last); // 要素間の距離:最初は要素数から
Iterator iter1, iter2;
bool swapped;
do {
    gap = gap / gap_ratio; // ちょびっと狭める
    if ( gap == 0 ) gap = 1;
    swapped = false;
    Iterator iter1 = first;
    Iterator iter2 = first;
    std::advance(iter2,gap); // iter1,iter2間をgapだけ離す
    while ( iter2 != last ) { // これ以降はbubblesortと同じね
      if ( *iter2 < *iter1 ) {
        swapped = true;
        std::iter_swap(iter1,iter2);
      }
      ++iter1;
      ++iter2;
    }
} while (swapped || gap != 1);
}

void random_test() {
const int N = 50000;
array<int,N> source;
array<int,N> target;
iota(source.begin(), source.end(), 0); // [0..N) の配列を用意
map<int,double> hist;
const int trial = 10;
for ( int t = 0; t < trial; ++t ) {
    random_shuffle(source.begin(), source.end()); // ぐちょぐちょにかき混ぜて
    double time;
    for ( int i = 110; i < 140; ++i ) {
      double ratio = i / 100.0;
      copy(source.begin(), source.end(), target.begin());
      {
        orz::ScopedWatch watch(time);
        combsort(target.begin(), target.end(), ratio); // 昆布ソート
      }
      if ( is_sorted(target.begin(),target.end()) ) {
        hist[i] += time; // 所要時間を積算
      } else {
        cout << "oops. disordered!" << endl;
        return;
      }
    }
}
// 平均値を出力
for ( int i = 120; i < 140; ++i ) {
    cout << "ratio= " << i/100.0 << " time=" << hist[i]/trial << endl;
}

}

結果:
ratio= 1.2 time=6.64967
ratio= 1.21 time=6.56539
ratio= 1.22 time=6.37233
ratio= 1.23 time=6.56348
ratio= 1.24 time=6.18083
ratio= 1.25 time=6.18782
ratio= 1.26 time=6.25421
ratio= 1.27 time=6.07581
ratio= 1.28 time=6.26599
ratio= 1.29 time=6.02135
ratio= 1.3 time=6.55121
ratio= 1.31 time=6.80597
ratio= 1.32 time=6.47621
ratio= 1.33 time=6.12299
ratio= 1.34 time=6.59149
ratio= 1.35 time=13.3166
ratio= 1.36 time=20.2281
ratio= 1.37 time=34.2606
ratio= 1.38 time=54.2303
ratio= 1.39 time=64.2049

ふむ、この場合に限って言えば 1.29 のときが最速。
1.33のあたりにヘコみがあるのも面白いですな。
とはいえ 1.3近傍が実験的によさげな値なのは確かなようです。

昆布じゃないのよ

επιστημη — Tue, 07 Dec 2010 22:03:00 GMT

なんとなーくアルゴリズムのお話など。

combsortてゆーソート・アルゴリズムがあります。
遅いので有名なbubblesortの改良版なんですけどね。

bubblesortがなして遅いかっちゅーと、隣接する二つの比較/交換を繰り返すので一回の交換で要素がちょびっとしか移動せんからなんですわ。
二要素間の距離を大きくとって交換し、次第に距離を狭めていくのがcombsortです。

#include <algorithm>
#include <iterator>

template<typename Iterator, typename Predicate>
void combsort(Iterator first, Iterator last, Predicate pred) {
auto gap = std::distance(first,last);　// 要素間の距離:最初は要素数から
Iterator iter1, iter2;
bool swapped;
do {
    gap = gap * 10 / 13; // ちょびっと狭める
    if ( gap == 0 ) gap = 1;
    swapped = false;
    Iterator iter1 = first;
    Iterator iter2 = first;
    std::advance(iter2,gap); // iter1,iter2間をgapだけ離す
    while ( iter2 != last ) { // これ以降はbubblesortと同じね
      if ( pred(*iter2,*iter1) ) {
        swapped = true;
        std::iter_swap(iter1,iter2);
      }
      ++iter1;
      ++iter2;
    }
} while (swapped || gap != 1);
}

要素間の距離:gapが繰り返しのたんびに 1/1.3 になってます。
この1/1.3て値、あんまり大きいと荒っぽすぎて効果がないし、小さいとなかなか収束しない。
実験的に求められた"よさげな値"が1/1.3らしいす。

わすれもので(ちょびっと)高速化

επιστημη — Wed, 23 Jun 2010 21:39:00 GMT

Visual C++ 2010に追加されたSTLアルゴリズム@CodeZine で忘れてたのがありました。

■ minmax_element
template<class Iterator, class Predicate>
std::pair<Iterator,Iterator>
minmax_element(Iterator first, Iterator last, Predicate pred);

シーケンス[first,last)から、最初に見つけた最小要素と最後に見つけた最大要素を指すイテレータをペアにして返します。

最小/最大要素を見つけてくれるアルゴリズムはそれぞれmin_element/max_elementがあるんだけど、minmax_elementはそいつらの合わせ技。
大きなメリットはmin_element,max_elementを一度ずつ呼び出すより速いす。要素数Nに対し3/2N程度だそうで、前者の2Nに比べて25%ほどの時短となるます。

コレ使って単純選択ソートをちょびっと速くします。単純選択ソートのアルゴリズムはめっちゃ単純:
「i=0..N-1に対し、data[i]～data[N-1]中の最少要素とdata[i]を交換する」こんだけ。コード書けば:

while ( first != last ) {
iter_swap(first, min_element(first,last));
++first;
}

loop回るたんびに未ソートな要素がいっこずつ減ってくんだから、minmax_elementならふたっつずつ減ってくれんでないのん? と。

ってなわけで書いてみた。ソート対象は挿入/削除がチョー速いlist<T>で。


#include <iostream>
#include <array>
#include <list>
#include <algorithm>
#include <numeric>
#include <cassert>
#include <windows.h>
using namespace std;
// フツーの単純選択ソート
DWORD min_selection_sort(list<int>& data) {
  DWORD t = GetTickCount();
  for ( auto first = data.begin(); first != data.end(); ++first ) {
    iter_swap(first,min_element(first,data.end()));
  }
  return GetTickCount() - t;
}
// ヒネクレた単純選択ソート
DWORD minmax_selection_sort(list<int>& data) {
  DWORD t = GetTickCount();
  list<int> smaller, bigger;
  while ( !data.empty() ) {
    auto mm_pair = minmax_element(data.begin(),data.end());
    smaller.splice(smaller.end(), data, mm_pair.first);
    if ( mm_pair.first != mm_pair.second ) {
      bigger.splice(bigger.begin(), data, mm_pair.second);
    }
  }
  data.splice(data.begin(),bigger);
  data.splice(data.begin(),smaller);
  return GetTickCount() - t;
}
int main() {
  const int N = 20000;
  array<int,N> src;
  iota(src.begin(),src.end(),0);
  random_shuffle(src.begin(),src.end());
  DWORD t;
  list<int> data;
  data.assign(src.begin(),src.end());
  t = min_selection_sort(data);
  assert( is_sorted(data.begin(), data.end()));
  cout << t << endl;
  data.assign(src.begin(),src.end());
  t = minmax_selection_sort(data);
  assert( is_sorted(data.begin(), data.end()));
  cout << t << endl;
}

実行結果:
1092 (min_selection)
967 (minmax_selection)

一割ちょいかー、けっこーややこしくなってっから、こんなもんかなー
もっとエレガントな実装がありそな希ガス。

並列処理が向かないかもしれない例

επιστημη — Tue, 22 Jun 2010 22:15:00 GMT

ネタ元 → Multi-Core と Multi-Thread のコメント:

どこまでをバブルソートと呼ぶかにもよるけど、交換の仕方を調整すると並列にできますよ、という例。
http://ja.wikipedia.org/wiki/奇偶転置ソート
ただ並列にする処理の1つ1つがとても小さいので、有意な差は出るかどうかは謎。

やってみよぉぢゃありませんか。
# いやさとっちゃんが急遽倍尺でやらんならんそぉなので、ネタ出しに協力的意味でｗｗｗ

1 7 6 5 8 2 4 3 があったとき、

[1] ふたつずつのペアをつくる。1 7 6 5 8 2 4 3
[2] それぞれのペアについて必要なら入れ替え 1 7 5 6 2 8 3 4
[3] ひとつずらしてペアをつくる 1 7 5 6 2 8 3 4
[4] それぞれのペアについて必要なら入れ替え1 5 7 2 6 3 8 4
[5] [1]～[4] をくりかえし。

[2],[4] の際、ペアの入れ替えは互いに独立だから並行処理できんぢゃん、と。


#include <iostream>
#include <algorithm>
#include <numeric>
#include <cassert>
#include <ppl.h>
#include <Windows.h>

using namespace std;
using namespace Concurrency;
// 単スレッドで地道にソート







void single_bubble_sort(int* data, int N) {
  bool swapped;
  auto swapper = [&](int i) { 
    if ( data[i] > data[i+1] ) {
      iter_swap(data+i,data+i+1);
      swapped = true;
    }
  };
  do {
    swapped = false;
    for ( int i = 0; i < N-1; i += 2 ) { swapper(i); }
    for ( int i = 1; i < N-1; i += 2 ) { swapper(i); }
  } while ( swapped );
}
// PPLで並行処理
void multi_bubble_sort(int* data, int N) {
  bool swapped;
  auto swapper = [&](int i) { 
    if ( data[i] > data[i+1] ) {
      iter_swap(data+i,data+i+1);
      swapped = true;
    }
  };
  do {
    swapped = false;
    parallel_for(0,N-1,2,swapper); // へーこー
    parallel_for(1,N-1,2,swapper); // しょり
  } while ( swapped );
}

int main() {
  const int N = 10000;
  int* src = new int[N];
  iota(src, src+N, 10);
  random_shuffle(src,src+N);
  int* data = new int[N];
  DWORD t0, t1;

  copy(src,src+N,data);
  t0 = GetTickCount();
  single_bubble_sort(data,N);
  t1 = GetTickCount();
  assert( is_sorted(data,data+N) );
  cout << (t1 - t0) << endl;

  copy(src,src+N,data);
  t0 = GetTickCount();
  multi_bubble_sort(data,N);
  t1 = GetTickCount();
  assert( is_sorted(data,data+N) );
  cout << (t1 - t0) << endl;
  delete[] data;
  delete[] src;
}

こいつを実行するとですね:
171 (single)
2855 (multi)
なんともトホホな結果です。処理単位があまりにちんこいために、
スレッド/タスクこしらえたり切り替えたりのコストをペイできんのですな。
# dual-coreでの結果です。octa-coreくらいになればちっとはマシかも。

データ構造なめんな

επιστημη — Sun, 06 Dec 2009 01:13:00 GMT

ネタ元 → 例外に依存するロジックは駄目ですよ

ほほぉ、なかなかに興味深い実験でございます。

　「このケースのように、事前に対象データの絞り込みは言語で
　　行うほうが良いケースもあります。」

SQLわからんちんの僕には胸のすく思い。

もちっと速くなるかもしんないなーってんでちょいと実験です。


using System;
using System.Collections.Generic;
using System.Diagnostics;

class Program {

  static long AddUnique<T>(IEnumerable<T> src, ICollection<T> dst) {
    Stopwatch watch = Stopwatch.StartNew();
    foreach ( T item in src ) {
      if ( !dst.Contains(item) ) { // 重複なければ
        dst.Add(item); // 追加
      }
    }
    watch.Stop();
    return watch.ElapsedMilliseconds;
  }

  public static void Main() {
    int N = 100000; // 要素数
    int M = 10000; // 値の上限
    // 元ネタ生成
    int[] src = new int[N];
    var r = new Random();
    for ( int i = 0; i < N; ++i )src[i] = r.Next(M);
    // 3つのCollectionで比べてみよう
    Console.WriteLine("LinkedList : {0}[ms]",AddUnique(src, new LinkedList<int>()));
    Console.WriteLine("List       : {0}[ms]",AddUnique(src, new List<int>()));
    Console.WriteLine("HashSet    : {0}[ms]",AddUnique(src, new HashSet<int>()));
  }
}

実行結果:
LinkedList : 4729[ms]
List : 3503[ms]
HashSet : 17[ms]

Hashすげー。

かき混ぜてはいかがでしょうか C++版

επιστημη — Wed, 22 Jul 2009 13:08:00 GMT

かき混ぜてはいかがでしょうかのつづき...ってゆーか、
ラムダがあんまりおもろいもんで、遊んでみたかっただけさ。

#include <iostream>
#include <iomanip>
#include <random>
#include <algorithm>
#include <vector>
#include <list>

namespace std { using namespace std::tr1; }

int main() {
  const int N = 20;
  typedef std::list<int> container;
  container data(N); // 要素数Nのコンテナ

  int i = 0;
  // 1..Nで埋める
  std::generate_n(data.begin(), data.size(), [i]() mutable { return ++i; });

  // シャッフル前
  std::cout << "\nbefore : ";
  std::for_each(data.begin(), data.end(), [](int item) { std::cout << std::setw(3) << item;});

  std::mt19937 mt; // メルセンヌ・ツイスター
  std::uniform_int<> dist; // 一様分布

  // ネタ元とおんなじアルゴリズム
  container::iterator tail = data.end();
  for ( int size = data.size(); size != 0; --size ) {
    // "size未満の乱数"番目と末尾要素とを入れ替える
    container::iterator position= data.begin();
    std::advance(position,dist(mt,size));
    std::iter_swap(position, --tail);
  }

  // シャッフル後
  std::cout << "\nafter  : ";
  std::for_each(data.begin(), data.end(), [](int item) { std::cout << std::setw(3) << item;});

}

かき混ぜてはいかがでしょうか

επιστημη — Mon, 13 Jul 2009 13:23:00 GMT

ネタ元 → シャッフル → トランプのシャッフル

僕ならこうやる。
配列を用意する。ナカミは01～13を入れておく。

01 02 03 04 05 06 07 08 09 10 11 12 13|

縦棒'|'の左をシャッフル前、右をシャッフル後とする。
シャッフル前の要素の中からでたらめにひとつ選び、
シャッフル前の末尾要素と入れ替えて|を左にずらす。
たとえばでたらめに05を選んだなら:

01 02 03 04 13 06 07 08 09 10 11 12|05

同じこと、つまり：
シャッフル前の要素の中からでたらめにひとつ選び、
シャッフル前の末尾要素と入れ替えて|を左にずらす。
たとえばでたらめに10を選んだなら:

01 02 03 04 13 06 07 08 09 12 11|10 05

以下同文に繰り返し、| が左端に達したらシャッフル完了。

VB.NETで書いてみた。

Module ShuffleDemo

    ' x と y を交換する
    Sub Swap(ByRef x As Integer, ByRef y As Integer)
        Dim t As Integer = x
        x = y
        y = t
    End Sub

    ' data() をかき混ぜる
    Sub Shuffle(ByVal data As Integer())
        Dim rnd As New Random()
        For n As Integer = data.Length To 1 Step -1
            ' "n未満の乱数"番目と "n-1"番目とを入れ替える
            Swap(data(rnd.Next(n)), data(n - 1))
        Next
    End Sub

    Sub Main()
        Dim data(13) As Integer
        ' data() を 1, 2, 3, ... 13 で埋める
        For i As Integer = 0 To data.Length - 1
            data(i) = i + 1
        Next
        ' シャッフルシャッフルぅ
        Shuffle(data)
        ' 結果の確認
        For Each item As Integer In data
            Console.Write("{0} ", item)
        Next
    End Sub

End Module

簡単ぢゃーん♪