<?xml version="1.0" encoding="utf-8" ?>
<rss version="2.0"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xml:lang="ja">
	<channel>
		<title>cafelier@SRM</title>
		<link>http://topcoder.g.hatena.ne.jp/cafelier/</link>
		<description>cafelier@SRM</description>
		<dc:creator>cafelier</dc:creator>


		<item>
			<title>[その他] ICPC 2019 Japan Domestic 問題F</title>
			<link>https://topcoder.g.hatena.ne.jp/cafelier/20190719/1563719461</link>

			<description><![CDATA[
		<div class="section">
			<p><a href="https://icpc.iisf.or.jp/2019-yokohama/2019kokunaiyosen/">ICPC 2019 国内予選</a> の問題F (<a href="http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1637&lang=jp">AOJ:1637</a>) について考えてみたよ、というか、色んな人の色んな解法を聞いて面白かったので自分なりにまとめてみました。</p>
			<p>こういう問題です。『無向グラフが与えられます。頂点を押すと、その頂点と他の全ての頂点の接続関係が反転します。辺で繋がってたところは辺が消え、繋がってなかったところには辺が生えます。この操作を繰り返して全域木が作れますか。作れるならコスト最小のものを。』</p>
			<h4> 脱線</h4>
			<p>ところで、こういう頂点の周りの辺を反転する操作は <b>Seidel のスイッチング</b> と呼ばれていて、元々は楕円幾何学という数学の問題を解くための道具として研究され始めたようです。</p>
			<ul>
				<li> <a href="https://research.tue.nl/en/publications/equilateral-point-sets-in-elliptic-geometry">J. H. van Lint and J. J. Seidel, "<b>Equilateral Point Sets in Elliptic Geometry</b>"</a></li>
			</ul>			<br>

			<p>Equilateral Point Set というのは多分どの2点間の距離も等しいような点集合ということで、2次元ユークリッド平面上だったら正三角形の頂点3点がEquilateralだし、3次元ユークリッド空間なら正四面体で4点かな？楕円幾何学という曲がった空間だともっと大きな点集合がEquilateralになり得るのですが、さて実際のところ、r次元の空間で最大何点がEquilateralになるのだろうか、求めたい、というお話だったそうです。</p>
			<p>なぜグラフが出てくるかというと、この幾何の問題は行列にエンコードすることができて、n*n行列に対してある操作を繰り返した結果の行列の固有値がある条件を満たせばEquilateral、みたいになるのですが、その行列をグラフの隣接行列として解釈すると、行列操作がグラフのSeidelのスイッチングに対応するのだとか（よくわかってないのであやふやなコメントです。）</p>
			<p>というわけでこの論文では、7次元のEquilateral setを求めるために、7頂点グラフを反転させまくって作れる同値類を列挙して(page 339-340)楽しんでいました。楽しそうですね。</p>			<br>

			<p><a href="https://www.google.co.jp/search?q=">Seidel Switching で検索</a>してみると、最近は <b>スペクトラルグラフ理論</b> やグラフスペクトル理論と呼ばれる系のお話でよく参照されているようです。グラフを<a href="https://ja.wikipedia.org/wiki/%E9%9A%A3%E6%8E%A5%E8%A1%8C%E5%88%97">隣接行列</a>という行列の形で表現してみたり、最近バズっていた記事で<a href="https://qiita.com/lotz/items/094bffd77b24e37bf20e">行列冪乗と最短路計算を結びつけたり</a>みたいな話がありますけど、せっかく行列という線形代数っぽいものを持ち出すのだからもっと線形代数っぽい話をしようというのがスペクトラルグラフ理論で、具体的には、隣接行列などのグラフから作れる行列の<b>固有値</b>からグラフの性質を探る理論です。行列の掛け算くらいならまだしも、固有値なんてグラフ的に何か意味がある値になるんでしょうか。気になった方は、<a href="https://www.slideshare.net/irrrrr/ss-25911553">ir5さんによる「スペクトラルグラフ理論入門」</a>というスライドなどお勧めです。</p>			<br>

			<p>Seidel switching は、「特定の形のグラフに適用すると、固有値は変わらないが元のグラフと同型ではないグラフを作る」という道具としてよく言及されています。固有値が完全にグラフの形を語り切っているわけではなく抽象していることの証明として使われているわけですね。</p>			<br>

			<p>以上の話はアルゴリズムと言うよりはグラフ理論寄りの話でしたが、</p>
			<ul>
				<li> <a href="https://doi.org/10.1007/978-3-540-46464-8_5">A. Ehrenfeucht, J. Hage, T. Harju, and G. Rozenberg, <b>"Complexity Issues in Switching of Graphs"</b></a></li>
			</ul>			<br>

			<p>という研究などは、スイッチングで到達できる範囲内に条件を満たすグラフがあるかの判定問題の解き方や計算複雑性の考察をしています。目標のグラフに次数が低いノードが必ずあるならば多項式時間で見つけられる、などの、下の"方針A"で書いてあるような話も触れられています。</p>			<br>

			<p>だいぶ脱線してしまいました。問題を解きましょう。</p>
			<a name="seemore"></a>

		</div>
]]></description>

			<dc:creator>cafelier</dc:creator>

			<pubDate>Sun, 21 Jul 2019 14:31:01 GMT</pubDate>


			<category>その他</category>


		</item>

		<item>
			<title> 『純粋関数型データ構造』のためだけの超いい加減な Standard ML 入門</title>
			<link>https://topcoder.g.hatena.ne.jp/cafelier/20170428/1493389565</link>

			<description><![CDATA[
		<div class="section">
			<div class="hatena-asin-detail">
  <a href="http://www.amazon.co.jp/exec/obidos/ASIN/4048930567/hatena-hamazou-22/"><img src="https://images-fe.ssl-images-amazon.com/images/I/51PxIsCTlHL._SL160_.jpg" class="hatena-asin-detail-image" alt="純粋関数型データ構造" title="純粋関数型データ構造"></a>
  <div class="hatena-asin-detail-info">
    <p class="hatena-asin-detail-title"><a href="http://www.amazon.co.jp/exec/obidos/ASIN/4048930567/hatena-hamazou-22/">純粋関数型データ構造</a></p>
    <ul>
      
      <li><span class="hatena-asin-detail-label">作者:</span> <a href="http://d.hatena.ne.jp/keyword/Chris%20Okasaki" class="okeyword">Chris Okasaki</a>,<a href="http://d.hatena.ne.jp/keyword/%B0%F0%CD%D5%B0%EC%B9%C0" class="okeyword">稲葉一浩</a>,<a href="http://d.hatena.ne.jp/keyword/%B1%F3%C6%A3%D0%D2%B2%F0" class="okeyword">遠藤侑介</a></li>
      
      <li><span class="hatena-asin-detail-label">出版社/メーカー:</span> <a href="http://d.hatena.ne.jp/keyword/KADOKAWA" class="okeyword">KADOKAWA</a></li>
      
      <li><span class="hatena-asin-detail-label">発売日:</span> 2017/04/28</li>
                                                      <li><span class="hatena-asin-detail-label">メディア:</span> 単行本</li>
      
      <li><a href="http://d.hatena.ne.jp/asin/4048930567" target="_blank">この商品を含むブログ (1件) を見る</a></li>
    </ul>
  </div>
  <div class="hatena-asin-detail-foot"></div>
</div>

			<p>こういう本を翻訳しました。発売中です。よろしくお願いします。</p>
			<p>この本は名前にある通りデータ構造の本なんですが、中でも、「永続データ構造」と言われる種類のデータ構造に特化して、それだけを丸々一冊扱っています。Topcoderなどで永続データ構造が活躍する問題というのは、まだまだ中々マイナーですが、これから流行るといいなあと思っておりいます。qnighyさんの記事</p>
			<p><a href="http://qnighy.hatenablog.com/entry/2012/12/02/032851" target="_blank">http://qnighy.hatenablog.com/entry/2012/12/02/032851</a></p>
			<p>でいくつか例題が紹介されていました。</p>
			<p>さて、この本、面白いんですが、本の中のサンプルコードは全て Standard ML というプログラミング言語で書かれています。正直なところ馴染みのない方も多いのではないでしょうか。というわけでこの記事では、C++ や Java に慣れている人向けに、ものすごく大雑把に Standard ML を紹介します。</p>
			<p>データ構造に興味はあるけど知らないプログラミング言語で書いてあると読めるかどうかわからない･･･という方が読んでみる助けになれば幸いです。擬似コードを読むような気分で本のサンプルコードを違和感なく読めるいうところが目標です。この記事を読んでも Standard ML を書けるようにはならないと思います。</p>
			<h4> 実行環境</h4>
			<p>「読めればよい」が目標なので実行する必要はない気もしますが、一応。</p>
			<ul>
				<li> SML/NJ <a href="http://www.smlnj.org/" target="_blank">http://www.smlnj.org/</a></li>
				<li> SML# <a href="http://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/" target="_blank">http://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/</a></li>
			</ul>			<br>

			<p>などが人気のある処理系です。</p>
			<h4> 関数定義と呼び出し</h4>
			<p>例として</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> norm x y <span class="synStatement">=</span> x<span class="synStatement">*</span>x + y<span class="synStatement">*</span>y
</pre>

			<p>これがC言語でいうところの</p>
<pre class="syntax-highlight">
<span class="synType">int</span> norm(<span class="synType">int</span> x, <span class="synType">int</span> y) {
  <span class="synStatement">return</span> x*x + y*y;
}
</pre>

			<p>に当たります。つまり、fun というキーワードを使って</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> 関数名 引数<span class="synConstant">1</span> 引数<span class="synConstant">2</span> 引数<span class="synConstant">3</span> ... <span class="synStatement">=</span> 関数本体
</pre>

			<p>と書いてあるのが関数宣言です。引数の周りに括弧やコンマがないのが特徴的ですね。関数を呼び出すときも同じく括弧やコンマはつけずに</p>
<pre class="syntax-highlight">
norm <span class="synConstant">1</span> <span class="synConstant">2</span>
</pre>

			<p>とかやれば 5 になります。普通の演算子よりも関数呼び出しの方が結合が強いので、</p>
<pre class="syntax-highlight">
norm <span class="synConstant">1</span> <span class="synConstant">2</span> + <span class="synConstant">3</span>
</pre>

			<p>は (norm 1 2) + 3 と同じ意味で、8 です。26にしたい時は足し算の方に括弧をつけて norm 1 (2 + 3) とします。</p>
			<p>こういう構文になっているのには「<a href="https://ja.wikipedia.org/wiki/%E3%82%AB%E3%83%AA%E3%83%BC%E5%8C%96">カリー化</a>」などの理由があるんですが、純粋関数型データ構造の本を読む分には特に関係がないので、そういう風習なのだと割り切って読むとよいと思います。</p>
			<h4> 変数/定数定義</h4>
			<p>val というキーワードで宣言します。</p>
<pre class="syntax-highlight">
<span class="synStatement">val</span> pi <span class="synStatement">=</span> <span class="synConstant">3.14</span>
</pre>

			<p>関数の中でローカル変数を定義するときは let ～ in ～ end と書きます。</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> average x y z <span class="synStatement">=</span>
  <span class="synStatement">let</span> <span class="synStatement">val</span> s <span class="synStatement">=</span> x + y + z <span class="synStatement">in</span>
    s <span class="synStatement">div</span> <span class="synConstant">3</span> 
  <span class="synStatement">end</span>
</pre>

			<p>"let val s = ... in ～" というのは、 "～ という式の中では s を ... とする" みたいな英語的気分です。</p>
			<p>この本は永続データ構造の本なので、一度作った値は絶対に壊しません。つまり、一度宣言した変数に別の値を後から再代入したりしません。なので、変数は val で初期値を指定して宣言するだけで、代入をする構文とかは出てきません。</p>
			<h4> 型の定義（ツリー構造の定義）</h4>
			<p>こういうことを言うともしかしたら Standard ML 好きな人に怒られたりするかもしれないんですが、私の中では(Standard) MLというのは、ツリー構造の操作に特化した最強ツリー処理専用言語です。大抵の強まったデータ構造というのは工夫して構築されたツリー構造なわけで、だからこそデータ構造の解説書である本書では、最強のツリー処理言語であるMLが選ばれているわけです。</p>
			<p>たとえば、整数値を格納する赤黒木の定義はこんな感じ。</p>
<pre class="syntax-highlight">
<span class="synStatement">datatype</span> <span class="synConstant">Rbtree</span> <span class="synStatement">=</span> <span class="synConstant">E</span>
                <span class="synStatement">|</span> <span class="synConstant">R</span> <span class="synStatement">of</span> <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> <span class="synType">int</span> <span class="synStatement">*</span> <span class="synConstant">Rbtree</span>
                <span class="synStatement">|</span> <span class="synConstant">B</span> <span class="synStatement">of</span> <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> <span class="synType">int</span> <span class="synStatement">*</span> <span class="synConstant">Rbtree</span>
</pre>

			<p>datatype というキーワードで新しい型を定義するんですが、新しい型というのは要するに、新しい種類の木を定義しています。ここで定義されている木にはEとRとBという三種類のノードがあると言っています。</p>
			<p><a href="http://f.hatena.ne.jp/cafelier/20170428211145" class="hatena-fotolife" target="_blank"><img src="http://cdn-ak.f.st-hatena.com/images/fotolife/c/cafelier/20170428/20170428211145.png" alt="f:id:cafelier:20170428211145p:image:w400" title="f:id:cafelier:20170428211145p:image:w400" class="hatena-fotolife" width="400"></a></p>
			<p>Eノードには子供がない、つまり葉ノードですね。RやBノードには左の子と、格納しているint値と、右の子があります。こういう三種類のノードでできているツリー構造というのに Rbtree という名前をつけて定義しているわけです。</p>
<pre class="syntax-highlight">
<span class="synStatement">datatype</span> 型の名前 <span class="synStatement">=</span> ノードのラベル<span class="synConstant">1</span> <span class="synStatement">of</span> <span class="synStatement">(</span>そのノードの持つ情報<span class="synStatement">(</span>子ノードとか<span class="synStatement">)</span> <span class="synStatement">*</span> ... <span class="synStatement">)</span>
                  <span class="synStatement">|</span> ノードのラベル<span class="synConstant">2</span> <span class="synStatement">of</span> <span class="synStatement">(</span>そのノードの持つ情報<span class="synStatement">(</span>子ノードとか<span class="synStatement">)</span> <span class="synStatement">*</span> ... <span class="synStatement">)</span>
                  <span class="synStatement">|</span> ...
</pre>
			<br>

			<p>という形で、何種類かノードがあるツリー構造の型を宣言します。この型の具体的な値を作るときには、こんな風に、今度は括弧とコンマで子などの情報を指定して</p>
<pre class="syntax-highlight">
<span class="synConstant">R</span> <span class="synStatement">(</span><span class="synConstant">B</span> <span class="synStatement">(</span><span class="synConstant">E</span>,<span class="synConstant">12</span>,<span class="synConstant">E</span><span class="synStatement">)</span>, <span class="synConstant">34</span>, <span class="synConstant">E</span><span class="synStatement">)</span>
</pre>

			<p><a href="http://f.hatena.ne.jp/cafelier/20170428212210" class="hatena-fotolife" target="_blank"><img src="http://cdn-ak.f.st-hatena.com/images/fotolife/c/cafelier/20170428/20170428212210.png" alt="f:id:cafelier:20170428212210p:image:w400" title="f:id:cafelier:20170428212210p:image:w400" class="hatena-fotolife" width="400"></a></p>
			<p>こうします。R や B や E のことを構築子（コンストラクタ）と呼びます。C++やJavaのコンストラクタとある意味同じで、ツリーのノードというオブジェクトを作る関数というわけです。</p>
			<h4> パターンマッチ（ツリー構造の操作）</h4>
			<p>ツリー構造を走査して操作する関数というのは大抵、ノードの種類ごとに場合が分かれて処理しつつ再帰していくことになります。この時に、「どのラベルのノードなのかの判定・分岐」と、「分岐したあとのノードの内部情報を変数におく」を一度に書ける構文が、パターンマッチです。</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> count_red <span class="synConstant">E</span> <span class="synStatement">=</span> <span class="synConstant">0</span>
  <span class="synStatement">|</span> count_red <span class="synStatement">(</span><span class="synConstant">B</span> <span class="synStatement">(</span>left, <span class="synStatement">_</span>, right<span class="synStatement">))</span> <span class="synStatement">=</span> count_red left + count_red right
  <span class="synStatement">|</span> count_red <span class="synStatement">(</span><span class="synConstant">R</span> <span class="synStatement">(</span>left, <span class="synStatement">_</span>, right<span class="synStatement">))</span> <span class="synStatement">=</span> <span class="synConstant">1</span> + count_red left + count_red right
</pre>

			<p>これは赤黒木の中の赤のノードの個数を数える関数。Eの場合、Bの場合、Rの場合に分岐しつつ、左の子や右の子を表すフィールドを変数にしてから関数本体へ突入しています。ノードの中でも要らない情報（この場合ノードに入っているint値）のところは _ と書いておくと無視できます。</p>
			<p>パターンは多段に重ねることもできて</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> foo <span class="synStatement">(</span><span class="synConstant">R</span> <span class="synStatement">(</span><span class="synConstant">R</span> <span class="synStatement">(_</span>, <span class="synStatement">_</span>, <span class="synStatement">_)</span>, <span class="synStatement">_</span>, <span class="synStatement">_))</span> <span class="synStatement">=</span> ...
  <span class="synStatement">|</span> foo <span class="synStatement">_</span> <span class="synStatement">=</span> ...
</pre>

			<p>とすれば、「左の子もRであるようなRノードとそれ以外」 という分岐になります。このパターンマッチによって、ツリーで作るデータ構造の操作がとても簡潔に表現できます。</p>
			<p><a href="http://shuns.sblo.jp/article/28490553.html" target="_blank">http://shuns.sblo.jp/article/28490553.html</a></p>
			<p>という記事に赤黒木の再平衡の実装の例があります。（こちらの記事は Haskell という言語を使っているのですが、まあだいたい Standard ML でも同じです。）</p>
			<h4> asパターン</h4>
			<p>パターンマッチで分解して中のノードのラベルとかは調べたいんだけど、変数におくのは分解しないでそのノードを指したい、といった時に出てくるのが as パターンです。</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> foo <span class="synStatement">(</span><span class="synConstant">R</span> <span class="synStatement">(</span>left as <span class="synConstant">R</span> <span class="synStatement">(_</span>, <span class="synStatement">_</span>, <span class="synStatement">_)</span>, <span class="synStatement">_</span>, right<span class="synStatement">))</span> <span class="synStatement">=</span> ...
  <span class="synStatement">|</span> foo <span class="synStatement">_</span> <span class="synStatement">=</span> ...
</pre>

			<p>「左の子もRであるようなRノード」が渡されたときに最初の分岐に行くのは先程の例と変わりませんが、同時に、そのRであるような左の子をleftという変数で指しています。</p>			<br>

			<h4> 多相型</h4>
			<p>さっきの赤黒木だとintしかツリーに持たせられませんでしたが、場合によって格納する型を変えたいですよね。C++でいうtemplate、JavaでいうGenericsです。Standard ML では多相型といいます。C++やJavaだとRbtree&#60;T&#62;みたいな、型名の後に&#60;&#62;という尖った括弧でパラメタ型Tを書きますが、Standard ML だと、型名の前にポンとパラメタ型を書きます。</p>
<pre class="syntax-highlight">
<span class="synStatement">datatype</span> 'a <span class="synConstant">Rbtree</span> <span class="synStatement">=</span> <span class="synConstant">E</span>
                   <span class="synStatement">|</span> <span class="synConstant">R</span> <span class="synStatement">of</span> 'a <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> 'a <span class="synStatement">*</span> 'a <span class="synConstant">Rbtree</span>
                   <span class="synStatement">|</span> <span class="synConstant">B</span> <span class="synStatement">of</span> 'a <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> 'a <span class="synStatement">*</span> 'a <span class="synConstant">Rbtree</span>
</pre>

			<p>'a という ' のついたのがパラメタ型で、"int Rbtree" ならintが入る赤黒木に、"string Rbtree"なら文字列が入る赤黒木の型になるわけですね。</p>
			<p>'a という表記はASCIIの範囲でソースコードを記述するための仮の姿で、実は、Standard ML使いにはこれはギリシャ文字の α という文字に見えています。というわけで本に書くときは全部こういうのは</p>
<pre class="syntax-highlight">
<span class="synStatement">datatype</span> α <span class="synConstant">Rbtree</span> <span class="synStatement">=</span> <span class="synConstant">E</span>
                   <span class="synStatement">|</span> <span class="synConstant">R</span> <span class="synStatement">of</span> α <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> α <span class="synStatement">*</span> α <span class="synConstant">Rbtree</span>
                   <span class="synStatement">|</span> <span class="synConstant">B</span> <span class="synStatement">of</span> α <span class="synConstant">Rbtree</span> <span class="synStatement">*</span> α <span class="synStatement">*</span> α <span class="synConstant">Rbtree</span>
</pre>

			<p>と書いてあります。</p>
			<h4> リスト</h4>
			<p>リストというのは子が１つしかないノードが繋がっているツリーと考えることができます。CやJavaでは配列が言語に組み込みのデータ型として基本となっていますが、Standard ML では、リストが標準に用意されていて、基本的なデータ型としてあらゆる場面で使われます。</p>
			<p>空のリストを表す [] が葉ノードで、格納した値と次のノードの二つの要素を持つノード :: が、標準のリストの構築子です。</p>
			<p><a href="http://f.hatena.ne.jp/cafelier/20170428224125" class="hatena-fotolife" target="_blank"><img src="http://cdn-ak.f.st-hatena.com/images/fotolife/c/cafelier/20170428/20170428224125.png" alt="f:id:cafelier:20170428224125p:image:w400" title="f:id:cafelier:20170428224125p:image:w400" class="hatena-fotolife" width="400"></a></p>
			<p>::は便利さを考えて、中置演算子として書けるようになっています。</p>
<pre class="syntax-highlight">
<span class="synConstant">1</span> <span class="synStatement">::</span> <span class="synConstant">2</span> <span class="synStatement">::</span> <span class="synConstant">3</span> <span class="synStatement">::</span> <span class="synConstant">[]</span>
</pre>

			<p>と書くと1,2,3というリストになります。</p>
			<p><a href="http://f.hatena.ne.jp/cafelier/20170428224327" class="hatena-fotolife" target="_blank"><img src="http://cdn-ak.f.st-hatena.com/images/fotolife/c/cafelier/20170428/20170428224327.png" alt="f:id:cafelier:20170428224327p:image:w400" title="f:id:cafelier:20170428224327p:image:w400" class="hatena-fotolife" width="400"></a></p>
			<p>長いリストを書くのに便利なような専用の略記法も用意されていて</p>
<pre class="syntax-highlight">
<span class="synStatement">[</span><span class="synConstant">1</span>,<span class="synConstant">2</span>,<span class="synConstant">3</span><span class="synStatement">]</span>
</pre>

			<p>と書いても同じ意味になります。もちろんのこのリストを表したツリーを処理するときにはパターンマッチが使えて、例えばintのリストの値の総和を取るには</p>
<pre class="syntax-highlight">
<span class="synStatement">fun</span> sum <span class="synConstant">[]</span> <span class="synStatement">=</span> <span class="synConstant">0</span>
  <span class="synStatement">|</span> sum <span class="synStatement">(</span>x <span class="synStatement">::</span> next<span class="synStatement">)</span> <span class="synStatement">=</span> x + sum next
</pre>

			<p>こんな感じ。</p>
			<h4> シグネチャ・ストラクチャ・ファンクタ</h4>
			<p>この本、一番最初に出てくるサンプルコードが signature と structure というものをいきなり使っていて仰々しいのですが、あまり身構えずに適当に雰囲気で読み飛ばしましょう。誤解を恐れずにいうと、</p>
			<ul>
				<li> シグネチャはC++でいうとヘッダファイル(hogehoge.h)みたいなもので、型とか関数とかの宣言だけを集めたもの</li>
				<li> ストラクチャはhogehoge.ccファイルみたいなものでシグネチャで宣言したものの具体的な実装</li>
			</ul>			<br>

			<p>くらいの理解で最初はなんとなく雰囲気で読めると思います。</p>
			<p>いや、「ヘッダファイルみたいなもの」は実のところ流石にちょっと適当に言い過ぎました。C++のヘッダで宣言した関数に対して実装は一つしかありませんが、シグネチャに対しては何個も違う実装をすることができます。</p>
			<ul>
				<li> シグネチャはJavaでいうインターフェイスみたいなもの、関数の型の宣言だけ集めたもの</li>
				<li> ストラクチャは具体的なクラスみたいなもので、インターフェイスで宣言した関数の具体的な実装</li>
			</ul>			<br>

			<p>の方が近いかな。Javaの標準ライブラリにある名前を借りると、Listシグネチャを実装するArrayListストラクチャやLinkedListストラクチャ、みたいな。ただし、Javaのインターフェイスやクラスは一つの型とその複数のメソッドを宣言/定義する物ですが、Standard ML のシグネチャやストラクチャは、複数の型と複数の関数のまとまりを宣言/定義します。</p>
			<p>C++でいうと<a href="http://en.cppreference.com/w/cpp/container/priority_queue:priority_queue" target="_blank">http://en.cppreference.com/w/cpp/container/priority_queue:priority_queue</a>が実装にどんなコンテナを使うのか指定できるような感じで、「別のストラクチャをパラメタとして受け取って使うストラクチャ」が作れると便利です。こういうことをするのが functor というキーワードで定義される「ファンクタ」です。</p>
			<p>たぶんこの辺りは本の具体的な例を読んでいただいた方が理解しやすそうです。</p>			<br>

			<h4> 質問など</h4>
			<p>ありましたらなんでも <a href="http://twitter.com/kinaba" target="_blank">http://twitter.com/kinaba</a> まで気軽に投げつけてください。</p>
		</div>
]]></description>

			<dc:creator>cafelier</dc:creator>

			<pubDate>Fri, 28 Apr 2017 14:26:05 GMT</pubDate>



		</item>

		<item>
			<title>[SRM]SRM610 Div1 550</title>
			<link>https://topcoder.g.hatena.ne.jp/cafelier/20140226/1393412591</link>

			<description><![CDATA[
		<div class="section">
			<ul>
				<li> 入力
				<ul>
					<li> 初期燃料 F</li>
					<li> タスクの集合 T = (d[0],r[0]), (d[1],r[1]), ... (d[N-1],r[N-1])</li>
				</ul>
				</li>
				<li> 求めるもの
				<ol>
					<li> 初期値 f = F</li>
					<li> Tから d&lt;=f であるような一組(d,r)を取り除き、f=f-d+r とする</li>
					<li> ステップ2を繰り返す</li>
					<li> できるだけ多くステップ2を繰り返せるように頑張ったら何回できますか</li>
				</ol>
				</li>
			</ul>
			<a name="seemore"></a>

		</div>
]]></description>

			<dc:creator>cafelier</dc:creator>

			<pubDate>Wed, 26 Feb 2014 11:03:11 GMT</pubDate>


			<category>SRM</category>


		</item>

		<item>
			<title>[その他] ACM-ICPC 2013 Aizu Regional 問題I</title>
			<link>https://topcoder.g.hatena.ne.jp/cafelier/20131124/1385307405</link>

			<description><![CDATA[
		<div class="section">
			<p><a href="http://sparth.u-aizu.ac.jp/icpc2013/r_overview.php?lang=jp">ACM-ICPC 2013 アジア地区予選会津大会</a> の問題Iを解いてみたよ。</p>
			<a name="seemore"></a>

		</div>
]]></description>

			<dc:creator>cafelier</dc:creator>

			<pubDate>Sun, 24 Nov 2013 15:36:45 GMT</pubDate>


			<category>その他</category>


		</item>

	</channel>
</rss>
