نمایش مبدأ برای الگوریتم استینهوس-جانسون-تروتر

'''الگوریتم استینهوس-جانسون-تروتر''' {{انگلیسی|Steinhaus–Johnson–Trotter algorithm}} [[الگوریتم|الگوریتمی]] برای یافتن یک شیوه از قرار دادن <math> n!</math> جایگشت به طول <math>n</math> پشت سر یکدیگر است به طوری که هر جایگشت در این ترتیب با جابجا کردن دو عنصر مجاور در جایگشت قبلی‌اش به دست می‌آید.{{سخ}}
نام این الگوریتم بر اساس نام سه دانشمند [[:en:Hugo_Steinhaus| هوگو استینهوس]]، [[سلمر مارتین جانسون]] و [[:en:Hale_Trotter|هیل‌فریمن تروتر]] بوده‌است که تقریباً در زمانی نزدیک و به صورت مجزا از هم به این الگوریتم رسیده بودند.

این الگوریتم برای ساختن ترتیبی از جایگشت‌ها در قرن ۱۷ام شناخته شد و
رابرت سجدویک<ref name="s77">{{Harvard citation text|Sedgewick, Robert (1977), "Permutation generation methods", ACM Comput. Surv., 9 (2): 137–164|doi:10.1145/356689.356692}}.</ref>
نیز به سرعت و سادگی این الگوریتم اشاره کرده‌است.

== دیدگاه از منظر گراف‌ها ==
[[پرونده:Symmetric group 4; Cayley graph 1,2,6 (3D); Steinhaus–Johnson–Trotter.svg|بندانگشتی|360px|مسیری همیلتونی در این گراف که الگوریتم فوق تولید می‌کند]]{{سخ}}
ابن مسئله معادل یافتن یک مسیر هامیلتونی در یک گراف است.{{سخ}}گراف را به این شکل می‌سازیم که برای هر یک از <math>n!</math> جایگشت موجود یک راس قرار دهیم و سپس بین دو راس یال می‌گذاریم اگر با '''یک‌بار''' جابجا کردن دو عنصر مجاور بتوانیم یکی را به دیگری تبدیل کنیم، به این گراف، '''[[:en:Permutohedron|گراف جایگشت‌ها]]''' می‌گویند.
{{سخ}}
مثلاً برای <math>n=4</math>، جایگشت <math><1, 2, 3, 4></math> به <math><1, 3, 2, 4></math> یال دارد ولی به
<math><3, 2, 1, 4></math> یال ندارد.
{{سخ}}
اکنون اگر بتوانیم مسیری هامیلتونی در این گراف بیابیم، در این صورت ترتیب پیمایش گراف، همان تعریف مطلوب است. الگوریتم مورد بحث نیز یک مسیر معتبر ارائه می‌دهد.

== شیوه استقرایی در یافتن دنباله جایگشت‌ها ==
* برای <math>n = 1</math> که مسئله واضح است و تک جایگشت <math><1></math> ترتیب مطلوب است.
* اکنون فرض می‌کنیم می‌توانیم ترتیبی از <math>n!</math> جایگشت بیابیم و ترتیبی برای جایگشت‌های به طول <math>n+1</math> پیدا می‌کنیم.
فرض کنید ترتیب در فرض استقرا <math>P_1, P_2, ..., P_{n!}</math> باشد. اکنون <math>Q_{i,j}</math> را به این شکل تعریف می‌کنیم.
* چنان‌چه <math>i</math> زوج باشد، <math>Q_{i,j}</math> جایگشتی است که از اضافه کردن <math>n + 1</math> به جایگاه <math>j</math>ام <math>P_i</math> به دست می‌آید.
* چنانچه <math>i</math> فرد باشد، <math>Q_{i,j}</math> جایگشتی است که از اضافه کردن <math>n+1</math> به جایگاه <math>n+2-j</math> جایگشت <math>P_i</math> به دست می‌آید.
{{سخ}}اکنون ترتیب مطلوب برای جایگشت‌های به طول <math>n + 1</math> را به این شکل می‌سازیم.
<math>Q_{1,1}, Q_{1,2}, ..., Q_{1,n+1}, ..., Q_{i,1}, Q_{i,2}, ..., Q_{i,n+1}, ..., Q_{n!, 1}, Q_{n!,2}, ..., Q_{n!, n+1}</math>

برای مثال اگر برای <math>n = 2</math> ترتیبی که فرض [[استقرا]] به ما می‌دهد، <math><1, 2>, <2, 1></math> باشد، در این‌صورت <math>P_1 = <1, 2> , P_2 = <2, 1></math> و با ساختن <math>Q_{i, j}</math>ها، ترتیب مطلوب برای <math>n = 3</math> به شکل{{سخ}}
<math><1, 2, 3></math>{{سخ}}
<math><1, 3, 2></math>{{سخ}}
<math><3, 1, 2></math>{{سخ}}
<math><3, 2, 1></math>{{سخ}}
<math><2, 3, 1></math>{{سخ}}
<math><2, 1, 3></math>{{سخ}}
خواهد بود.

=== اثبات ===
اکنون درستی این دنباله را نشان می‌دهیم. دو عنصر متوالی از دنباله را در نظر می‌گیریم و نشان می‌دهیم که با یک عملیات جابجایی دو عنصر مجاور به یکدیگر تبدیل می‌شوند.
فرض کنید دو جایگشت <math>k</math> و <math>k+1</math> را در نظر بگیریم دو حالت متصور است.
* اگر این دو جایگشت به شکل <math>Q_{i, j}, Q_{i, j+1}</math> باشند، در این‌صورت اگر <math>n+1</math> را از دو جایگشت حذف کنیم جایگشت یکسان <math>P_i</math> به دست می‌آید؛ و دو جایگشتی که ما بررسی می‌کنیم از اضافه کردن <math>n+1</math> به دو جایگاه متوالی از <math>P_i</math> به دست می‌آید. پس با جابجا کردن <math>n + 1</math> با عنصر کنارش از جایگشت <math>k</math> به جایگشت <math>k+1</math> می‌رسیم.
* اگر اگر این دو جایگشت به شکل <math>Q_{i, n+1}, Q_{i+1, 1}</math> باشد، در این صورت در تعریف ما، در هر دو این جایگشت‌ها <math>n+1</math> در یک سمت جایگشت است و بقیه جایگشت (بدون در نظر گرفتن <math>n+1</math>) جایگشت‌های <math>P_i, P_{i+1}</math> هستند که طبق فرض استقرا با یک عملیات به یکدیگر تبدیل می‌شوند.
{{سخ}}
برای اینکه اثبات کامل شود، لازم است نشان دهیم که جایگشت‌هایی که تولید می‌کنیم متمایزند. برای مثال <math>Q_{i_1, j_1}, Q_{i_2, j_2}</math> را در نظر بگیرید.
* اگر <math>i_1 = i_2</math> در این‌صورت چون <math>j_1 \neq j_2</math> مکان <math>n + 1</math> در این دو جایگشت تفاوت می‌کند لذا دو جایگشت متفاوتند.
* اگر <math>i_1 \neq i_2</math>، در این‌صورت جایگشت‌هایی که با حذف <math>n+1</math> به دست می‌آید <math>P_{i_1}, P_{i_2}</math> هستند که طبق فرض استقرا با یکدیگر متفاوتند لذا دو جایگشت <math>Q_{i_1, j_1}, Q_{i_2, j_2}</math> نیز متفاوتند.

== الگوریتم ==
الگوریتمی که در سال ۱۹۶۳ منتشر شد، دقیقاً ترتیب بالا را تولید می‌کند ولی نیازی به [[حل مسئله]] برای مقادیر کمتر و تولید دنباله‌های کوچک‌تر ندارد و به شکلی مستقیم و با شروع از حالت اولیه همه جایگشت‌ها را تولید می‌کند.<ref>{{Harvard citation text|Dershowitz, Nachum (1975), "A simplified loop-free algorithm for generating permutations", Nordisk Tidskr. Informationsbehandling (BIT), 15 (2): 158–164.|doi:10.1007/bf01932689, MR 0502206}}</ref><ref name="s77"/><ref name="a77">{{Harvard citation text|Ehrlich, Gideon (1973), "Loopless algorithms for generating permutations, combinations, and other combinatorial configurations", Journal of the ACM, 20 (3): 500–513.|doi:10.1145/321765.321781}} </ref>
{{سخ}}
برای هر عدد در جایگشت یک جهت تعریف می‌شود که یا '''به‌راست''' است یا '''به‌چپ'''. در ابتدا جایگشت <math><1, 2, ..., n></math> است و همه جهت‌ها به چپ هستند.{{سخ}}
سپس در هر گام یک ''mobile'' تعریف می‌کنیم که به این صورت محاسبه می‌شود.

# بزرگترین عددی است که از عدد سمت '''جهتش'''، بزرگتر است (یعنی برای اعدادی که جهتشان به‌چپ است آن را با عدد سمت چپش و برای اعدادی که جهت‌شان به‌راست است آن را با عدد سمت راستش مقایسه می‌کنیم) در میان اعدادی که از عدد مربوطه‌شان بزرگترند، بزرگ‌ترین را در نظر می‌گیریم و این عدد را ''mobile'' می‌نامیم.
# سپس این عدد را با عددی که جهتش اشاره می‌کند (یعنی همان عددی که با آن مقایسه شده‌است) جابجا می‌کنیم.
# در گام آخر، جهت همه اعدادی که از ''mobile'' بزرگترند را برعکس می‌کنیم. یعنی از به‌چپ به به‌راست و بالعکس.

هنگامی که دیگر ''mobile'' در جایگشت پیدا نشد، الگوریتم پایان می‌یابد و جایگشت‌های تولید شده در این میان، ترتیب مطلوب ما هستند.

فرایند را برای <math>n = 3</math> ببینید.{{سخ}}
<math> <1,<2,<3 </math>{{سخ}}
''mobile'' = ۳
{{سخ}}{{سخ}}
<math> <1,<3,<2 </math>{{سخ}}
''mobile'' = ۳
{{سخ}}{{سخ}}
<math> <3,<1,<2 </math>{{سخ}}
''mobile'' = ۲
{{سخ}}{{سخ}}
<math> >3,<2,<1 </math>{{سخ}}
''mobile'' = ۳
{{سخ}}{{سخ}}
<math> <2,>3,<1 </math>{{سخ}}
''mobile'' = ۳
{{سخ}}{{سخ}}
<math> <2,<1,>3 </math>{{سخ}}
دیگری ''mobile'' وجود ندارد. الگوریتم پایان می‌یابد.
{{سخ}}
مجدداً درستی الگوریتم با استقرا ثابت می‌شود.

=== پیچیدگی زمانی الگوریتم ===
در این الگوریتم <math>\theta(n!)</math> جایگشت تولید می‌شود که برای هر کدام <math>\theta(n)</math> هزینه برای یافتن ''mobile'' و جابجایی‌ها و برعکس‌کردن جهت‌ها لازم است؛ لذا هزینه الگوریتم <math>\theta(n.n!)</math> خواهد بود.

== ارتباط با کد گِرِی ==
کدگری در حالت کلی، ترتیبی از اعداد <math>n</math> رقمی در مبنایی دلخواه است، طوری که هر دو عدد مجاور در دقیقاً یک رقم تفاوت داشته باشند.{{سخ}}
اکنون به هر جایگشت یک دنباله متناظر می‌کنیم و ادعا می‌کنیم که دنباله‌های تولید شده توسط الگوریتمِ (که در [[:en:Factorial_number_system|مبنای فاکتوریل]] هستند)، خاصیت کدگری را دارند.{{سخ}}
برای هر جایگشت یک دنباله <math>C</math>، تعریف می‌کنیم که به این شکل حساب می‌شود.
* <math>c_i</math> را برابر تعداد اعداد کوچکتر از <math>i</math>، در سمت راست <math>i</math> در جایگشت تعریف می‌کنیم.{{سخ}}
مثلاً دنباله مربوطه برای <math><3, 1, 2, 5, 4></math> برابر با <math>C = <0, 0, 2, 0, 1> </math> خواهد بود.
{{سخ}}ابتدا نشان می‌دهیم که برای جایگشت‌های متفاوت دنباله <math>C</math> نیز متفاوت خواهد بود.{{سخ}}
نشان می‌دهیم دنباله <math><c_1, c_2, ..., c_n></math> جایگشتی یکتا تولید می‌کند.{{سخ}}
<math>c_n</math> را در نظر بگیرید، به سادگی می‌توان دریافت که در جایگشت جایگاه عدد <math>n</math>، برابر با <math>n - c_n</math> است. اکنون عدد <math>n</math> را حذف کنید و به شکلی بازگشتی بقیه اعداد را به شکل یکتا در جایگاه‌هایشان قرار دهید، تا همه اعداد در جایگشت قرار گیرند، در تمامی مراحل فرایند یکتاست، پس تنها یک جایگشت خاص، دنباله متناظرش <math>C</math> است.{{سخ}}{{سخ}}
می‌توان نشان داد ترتیبی که الگوریتم جانسون-تروتر تولید می‌کند دنباله‌های <math>C</math> می‌سازد که خاصیت [[کد گری]] را دارند، یعنی هر دو دنباله متوالی دقیقاً در یک رقم تفاوت دارند. (برای اثبات می‌توانید نشان دهید که اگر دو عضو متوالی از یک جایگشت را جابجا کنیم دقیقاً یکی از <math>c_i</math> تغییر می‌کند)<ref>{{Harvard citation text|Knuth, Donald (2011), "Section 7.2.1.2: Generating All Permutations", he Art of Computer Programm.|volume 4A}}</ref><ref>{{Harvard citation text|Dijkstra, Edsger W. (1976), "On a gauntlet thrown by David Gries", Acta Informatica, 6 (4): 357–359, doi:10.1007/BF00268136, MR 0426492.|Although DIjkstra does not cite any prior literature, an earlier draft EWD502 reveals that he knew of Trotter (1962)}}</ref>
{{سخ}}برای <math>n = 3</math> ،
جایگشت‌ها{{سخ}}
<math><1, 2, 3>, <1, 3, 2>, <3, 1, 2>, <3, 2, 1>, <2, 3, 1>, <2, 1, 3></math> هستند که دنباله‌های متناظر با آن‌ها برابر با
{{سخ}}
<math><0, 0, 0>, <0, 0, 1>, <0, 0, 2>, <0, 1, 2>, <0, 1, 1>, <0, 1, 0></math> است
و همان‌طور که مشاهده می‌شود، دنباله تولید شده خاصیت کد گری را دارد.

== جستارهای وابسته ==
* [[:en:Permutohedron|گراف جایگشت‌ها (Permutohedron)]]
* [[:کد گری]]
* [[:en:Factorial_number_system|مبنای فاکتوریل]]

== منابع ==
{{پانویس|30em|چپ‌چین=بله}}

[[رده:الگوریتم‌های ترکیبیاتی]]
[[رده:جایگشت‌ها]]