node2

September 3, 2018 By admin

ਜਾਣ ਪਛਾਣ

ਜਾਣ ਪਛਾਣ

ਪਾਠ ਪ੍ਰਾਸੈਸਿੰਗ ਦੇ ਵਿਸ਼ਾਲ ਡੋਮੇਨ ਵਿੱਚ ਸਤਰ-ਮੇਲ ਕਰਨਾ ਇੱਕ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ਾ ਹੈ. ਸਤਰ-ਮੇਲਿੰਗ ਐਲਗੋਰਿਥਮ ਬਹੁਤ ਸਾਰੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਦੇ ਅਧੀਨ ਮੌਜੂਦਾ ਪ੍ਰੈਕਟੀਕਲ ਸੌਫਟਵੇਅਰ ਦੇ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਮੂਲ ਕੰਪੋਨੈਂਟ ਹਨ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਉਹ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ‘ਤੇ ਜ਼ੋਰ ਦਿੰਦੇ ਹਨ ਜੋ ਕੰਪਿਊਟਰ ਸਾਇੰਸ (ਸਿਸਟਮ ਜਾਂ ਸਾਫਟਵੇਅਰ ਡਿਜਾਈਨ) ਦੇ ਦੂਜੇ ਖੇਤਰਾਂ ਵਿਚ ਪੈਰਾਡਿਫਮਾਂ ਦੇ ਤੌਰ’ ਤੇ ਸੇਵਾ ਕਰਦੇ ਹਨ. ਅਖੀਰ ਵਿੱਚ, ਉਹ ਚੁਣੌਤੀਪੂਰਨ ਸਮੱਸਿਆਵਾਂ ਦੇ ਕੇ ਤਕਨੀਕੀ ਸਿਧਾਂਤ ਵਿੱਚ ਇੱਕ ਅਹਿਮ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੇ ਹਨ.

ਹਾਲਾਂਕਿ ਡਾਟਾ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਯਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਾਣਕਾਰੀ ਨੂੰ ਬਦਲਣ ਲਈ ਪਾਠ ਮੁੱਖ ਰੂਪ ਵਿਚ ਰਹਿੰਦਾ ਹੈ. ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ‘ਤੇ ਸਾਹਿਤ ਜਾਂ ਭਾਸ਼ਾ ਵਿਗਿਆਨ ਵਿਚ ਸਪੱਸ਼ਟ ਹੁੰਦਾ ਹੈ, ਜਿੱਥੇ ਡਾਟਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸੰਗ੍ਰਹਿ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ. ਇਹ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਦੇ ਨਾਲ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਦੀ ਰਾਸ਼ੀ ਲਕੀਰ ਦੀਆਂ ਫਾਈਲਾਂ ਵਿਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਅਤੇ ਇਹ ਵੀ ਮਾਮਲਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਣੂ ਜੀਵ ਵਿਗਿਆਨ ਵਿੱਚ, ਕਿਉਂਕਿ ਜੈਿਵਕ ਪਰਮਾਣੂ ਅਕਸਰ ਨਿਊਕਲੀਓਟਾਇਡਸ ਜਾਂ ਐਮੀਨੋ ਐਸਿਡ ਦੀ ਲੜੀ ਵਜੋਂ ਅਨੁਮਾਨਿਤ ਹੋ ਸਕਦੇ ਹਨ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹਨਾਂ ਖੇਤਰਾਂ ਵਿਚ ਉਪਲਬਧ ਡਾਟੇ ਦੀ ਮਾਤਰਾ ਹਰੇਕ ਅਠਾਰਾ ਮਹੀਨੇ ਵਿਚ ਦੁੱਗਣੀ ਹੁੰਦੀ ਹੈ. ਇਹੋ ਕਾਰਨ ਹੈ ਕਿ ਅਲਗੋਰਿਦਮ ਕੁਸ਼ਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਭਾਵੇਂ ਕਿ ਕੰਪਿਊਟਰ ਅਤੇ ਕੰਪਿਊਟਰ ਦੀ ਸਟੋਰੇਜ ਦੀ ਸਮਰੱਥਾ ਤੇਜ਼ੀ ਨਾਲ ਵਧ ਰਹੀ ਹੈ.

ਸਤਰ ਮਿਲਾਨ ਇੱਕ ਸਤਰ ਦੇ ਸਾਰੇ ਮੌਜੂਦਗੀ (ਆਮ ਤੌਰ ਤੇ ਇੱਕ ਪੈਟਰਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਵਿੱਚ, ਇੱਕ ਜਾਂ ਵਧੇਰੇ ਆਮ ਤੌਰ ‘ਤੇ ਲੱਭਣ ਲਈ ਹੁੰਦੇ ਹਨ. ਇਸ ਕਿਤਾਬ ਵਿੱਚ ਸਾਰੇ ਐਲਗੋਰਿਥਮ ਪਾਠ ਵਿੱਚ ਪੈਟਰਨ ਦੀਆਂ ਸਾਰੀਆਂ ਮੌਜੂਦਗੀਆਂ ਨੂੰ ਆਉਟਪੁੱਟ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ. ਪੈਟਰਨ x = x [0 .. m-1] ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ; ਇਸਦੀ ਲੰਬਾਈ ਮੀਟਰ ਦੇ ਬਰਾਬਰ ਹੈ ਪਾਠ y = y [0 .. n-1] ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ; ਇਸਦੀ ਲੰਬਾਈ n ਦੇ ਬਰਾਬਰ ਹੈ. ਦੋਵੇਂ ਸਤਰਾਂ ਇੱਕ ਸੀਮਤ ਦੇ ਸੰਖੇਪ ਸਮੂਹ ਉੱਤੇ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ ਜਿਵੇਂ ਕਿ ਸਿਗਮਾ ਦੁਆਰਾ ਦਰਸਾਈ ਇੱਕ ਵਰਣਮਾਲਾ ਜਿਸਦਾ ਆਕਾਰ ਸਿਗਮਾ ਦੇ ਬਰਾਬਰ ਹੈ.

ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਕਿਸਮ ਦੇ ਹੱਲ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਕਿਸ ਸਟ੍ਰਿੰਗ, ਪੈਟਰਨ ਜਾਂ ਟੈਕਸਟ ਨੂੰ ਪਹਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਆਟੋਮੈਟਾ ਜਾਂ ਸਟਰਿੰਗਜ਼ ਦੀਆਂ ਜੋੜਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਐਲਗੋਰਿਥਮ ਆਮ ਤੌਰ ਤੇ ਪੈਟਰਨ ਨੂੰ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਕਰਨ ਅਤੇ ਪਹਿਲੀ ਕਿਸਮ ਦੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਕਰਨ ਲਈ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਰੁੱਖਾਂ ਜਾਂ ਆਟੋਮਾਟਾ ਦੁਆਰਾ ਅਹਿਸਾਸੀਆਂ ਗਈਆਂ ਸੂਚਕਾਂਕ ਦੀ ਧਾਰਨਾ ਦੂਜੀ ਕਿਸਮ ਦੇ ਹੱਲਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ. ਇਹ ਕਿਤਾਬ ਸਿਰਫ ਪਹਿਲੀ ਕਿਸਮ ਦੇ ਐਲਗੋਰਿਥਮ ਦੀ ਜਾਂਚ ਕਰੇਗੀ.

ਮੌਜੂਦਾ ਕਿਤਾਬ ਦੇ ਕੰਮ ਦੇ ਸਤਰ-ਮੇਲਿੰਗ ਅਲਗੋਰਿਦਮ ਇਸ ਤਰਾਂ ਹਨ. ਉਹ ਇੱਕ ਵਿੰਡੋ ਦੀ ਮੱਦਦ ਨਾਲ ਪਾਠ ਨੂੰ ਸਕੈਨ ਕਰਦੇ ਹਨ ਜੋ ਆਮ ਤੌਰ ਤੇ ਮੀਟਰ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ ਉਹ ਪਹਿਲਾਂ ਵਿੰਡੋ ਦੇ ਖੱਬੇ ਕੋਨਾਂ ਅਤੇ ਪਾਠ ਨੂੰ ਇਕਸਾਰ ਕਰਦੇ ਹਨ, ਫਿਰ ਵਿੰਡੋ ਦੇ ਅੱਖਰਾਂ ਦੀ ਤਰਤੀਬ ਦੇ ਅੱਖਰਾਂ ਨਾਲ ਤੁਲਨਾ ਕਰੋ – ਇਸ ਵਿਸ਼ੇਸ਼ ਕੰਮ ਨੂੰ ਇੱਕ ਕੋਸ਼ਿਸ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ – ਅਤੇ ਪੈਟਰਨ ਦੇ ਪੂਰੇ ਮੈਚ ਜਾਂ ਮਿਲਾਵਟ ਦੇ ਬਾਅਦ ਉਹ ਵਿੰਡੋ ਸੱਜੇ ਪਾਸੇ ਉਹ ਉਸੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਕਿ ਵਿੰਡੋ ਦਾ ਸੱਜਾ ਅੰਤ ਅੰਤ ਵਿੱਚ ਪਾਠ ਦੇ ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਬਾਹਰ ਹੁੰਦਾ ਹੈ. ਇਸ ਵਿਧੀ ਨੂੰ ਆਮ ਤੌਰ ਤੇ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਵਿਧੀ ਕਹਿੰਦੇ ਹਨ. ਅਸੀਂ ਹਰ ਇੱਕ ਕੋਸ਼ਿਸ਼ ਨੂੰ ਪੋਜੀਸ਼ਨ j ਨਾਲ ਟੈਕਸਟ ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ ਜਦੋਂ ਵਿੰਡੋ ਨੂੰ y ਤੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ [j .. j + m-1].

ਬਰੂਟ ਫੋਰਸ ਅਲਗੋਰਿਦਮ ਯੁੱਗ ਵਿੱਚ x ਦੇ ਸਾਰੇ ਮੌਜੂਦਗੀ O (mn) ਵਿੱਚ ਲੱਭਦਾ ਹੈ. ਬੁਰੱਕ ਫੋਰਸ ਵਿਧੀ ਦੇ ਬਹੁਤ ਸਾਰੇ ਸੁਧਾਰਾਂ ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ ਪੈਟਰਨ ਅੱਖਰਾਂ ਅਤੇ ਪਾਠ ਦੇ ਪਾਤਰਾਂ ਅਤੇ ਹਰੇਕ ਕੋਸ਼ਿਸ਼ ਦੇ ਵਿਚ ਤੁਲਨਾ ਦੇ ਆਦੇਸ਼ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ. ਚਾਰ ਸ਼੍ਰੇਣੀਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ: ਤੁਲਨਾ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਕੁਦਰਤੀ ਤਰੀਕਾ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਹੈ, ਜੋ ਕਿ ਪੜ੍ਹਨ ਦੀ ਦਿਸ਼ਾ ਹੈ; ਆਮ ਤੌਰ ਤੇ ਖੱਬੇ ਤੋਂ ਤੁਲਨਾ ਕਰ ਕੇ ਆਮ ਤੌਰ ਤੇ ਅਭਿਆਸ ਵਿਚ ਵਧੀਆ ਐਲਗੋਰਿਥਮ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ; ਸਭ ਤੋਂ ਵਧੀਆ ਸਿਧਾਂਤਕ ਸੀਮਾਵਾਂ ਉਦੋਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੁਲਨਾ ਇੱਕ ਖਾਸ ਕ੍ਰਮ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਅਖੀਰ ਵਿੱਚ ਕੁਝ ਐਲਗੋਰਿਥਮ ਮੌਜੂਦ ਹਨ, ਜਿਸ ਲਈ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਤੁਲਨਾ ਕੀਤੀ ਗਈ ਉਹ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹੈ (ਜਿਵੇਂ ਬੁਰਕੇ ਬਲ ਅਲਗੋਰਿਦਮ ਹੈ).

ਖੱਬੇ ਤੋਂ ਸੱਜੇ

ਹੈਸ਼ਿੰਗ ਇੱਕ ਸਾਧਾਰਣ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਕਿ ਸਭ ਤੋਂ ਪ੍ਰੈਕਟੀਕਲ ਹਾਲਤਾਂ ਵਿੱਚ ਅੱਖਰ ਦੀ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਟਾਲ ਲੈਂਦਾ ਹੈ ਅਤੇ ਜੋ ਵਾਜਬ ਸੰਭਾਵੀ ਧਾਰਨਾਵਾਂ ਦੇ ਅਧੀਨ ਰੇਖਾਬੱਧ ਸਮੇਂ ਵਿੱਚ ਚਲਦਾ ਹੈ. ਇਹ ਹੈਰੀਸਨ ਦੁਆਰਾ ਅਰੰਭ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਕਾਰਪ ਅਤੇ ਰਾਬੀਨ ਦੁਆਰਾ ਪੂਰੀ ਤਰਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਕੀਤਾ ਗਿਆ ਹੈ.

ਇਹ ਮੰਨਦੇ ਹੋਏ ਕਿ ਪੈਟਰਨ ਦੀ ਲੰਬਾਈ ਮਸ਼ੀਨ ਦੇ ਮੈਮੋਰੀ-ਵਰਡ ਸਾਈਜ਼ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ, ਸ਼ਿਫਟ ਜਾਂ ਅਲਗੋਰਿਦਮ ਸਹੀ ਸਤਰ-ਮੇਲ ਕਰਨ ਵਾਲੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਕੁਸ਼ਲ ਅਲਗੋਰਿਦਮ ਹੈ ਅਤੇ ਇਹ ਲਗਭਗ ਆਸਾਨੀ ਨਾਲ ਸਟ੍ਰਿੰਗ-ਮੇਲਿੰਗ ਸਮੱਸਿਆਵਾਂ ਦੀ ਇੱਕ ਵਿਆਪਕ ਲੜੀ ਲਈ ਅਨੁਕੂਲ ਹੁੰਦਾ ਹੈ.

ਪਹਿਲੀ ਰੇਖਾ-ਸਮਾਂ ਸਤਰ-ਮੇਲਿੰਗ ਅਲਗੋਰਿਦਮ ਮੌਰੀਅਸ ਅਤੇ ਪ੍ਰੈਟ ਤੋਂ ਹੈ. ਇਹ ਨੂਥ, ਮੌਰਿਸ ਅਤੇ ਪ੍ਰੈਟ ਦੁਆਰਾ ਸੁਧਾਰਿਆ ਗਿਆ ਹੈ. ਇਹ ਖੋਜ ਆਟੋਮੈਟਨ ਦੁਆਰਾ ਇੱਕ ਮਾਨਤਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ, ਅਤੇ ਪਾਠ ਦੀ ਇੱਕ ਚਰਿੱਤਰ ਨੂੰ ਲੌਗਫ਼ੀ (ਐਮ + 1) (ਫਾਈ ਸੋਨੇ ਦੀ ਅਨੁਪਾਤ ਸੁਨਹਿਰੀ ਅਨੁਪਾਤ) ਤੋਂ ਬਿਨਾਂ ਪੈਟਰਨ ਦੇ ਇੱਕ ਅੱਖਰ ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਗਈ ਹੈ. Hancart ਸਾਬਤ ਕਰਦਾ ਹੈ ਕਿ ਸਿਮੋਨ ਦੁਆਰਾ ਲੱਭੇ ਗਏ ਇੱਕ ਸਬੰਧਤ ਐਲਗੋਰਿਦਮ ਦੇ ਇਸ ਦੇਰੀ ਦਾ ਪਾਠ ਅੱਖਰ ਪ੍ਰਤੀ 1 + log2m ਤੁਲਨਾਵਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਬਣਦਾ. ਉਹ ਤਿੰਨ ਐਲਗੋਰਿਥਮ ਸਭ ਤੋਂ ਬੁਰਾ ਮਾਮਲੇ ਦੇ 2n-1 ਪਾਠ ਅੱਖਰ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਹਨ.

ਇਕ ਡਿਟਾਇਮਿੰਸਿਕ ਕੰਟਾਈਟ ਆਟੋਮੇਟੋਨ ਨਾਲ ਖੋਜ ਬਿਲਕੁਲ ਐਨ ਟੈਕਸਟ ਵਰਣ ਨਿਰੀਖਣ ਕਰਦੀ ਹੈ ਪਰ ਇਸ ਨੂੰ ਓ (ਐਮਸੀਗਾਮਾ) ਵਿੱਚ ਵਾਧੂ ਥਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਫਾਰਵਰਡ ਡੌਗ ਮਿਲਾਨਿੰਗ ਅਲਗੋਰਿਦਮ, ਪੈਟਰਨ ਦੇ ਪ੍ਰਭਾਵੀ ਆਟੋਮੈਟਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਿਲਕੁਲ ਉਹੀ ਅੱਖਰ ਜਾਂਚਾਂ ਕਰਦਾ ਹੈ.

ਅਪੋਸਟੋਲੀਕੋ-ਕੈਚਮੋਰ ਅਲਗੋਰਿਦਮ ਇੱਕ ਸਧਾਰਨ ਐਲਗੋਰਿਦਮ ਹੈ ਜੋ ਸਭ ਤੋਂ ਮਾੜੇ ਕੇਸ ਵਿੱਚ 3 / 2n ਪਾਠ ਅੱਖਰ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ.

ਨਾ ਤਾਂ ਨਾਜ਼ੁਕ ਅਲਗੋਰਿਦਮ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਣ ਅਲਗੋਰਿਦਮ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਸਭ ਤੋਂ ਬੁਰਾ ਕੇਸ ਵਾਰ ਦੀ ਗੁੰਝਲਦਾਰਤਾ ਦੇ ਨਾਲ ਹੈ ਪਰ ਇਸ ਨੂੰ ਸਥਿਰ ਸਮੇਂ ਅਤੇ ਸਪੇਸ ਵਿੱਚ ਪੂਰਵ-ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਪੜਾਅ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਔਸਤ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਥੋੜ੍ਹਾ ਉਪ-ਲੀਨੀਅਰ ਹੈ.

ਸੱਜੇ ਤੋਂ ਖੱਬੇ ਤੱਕ

ਬੋਇਰ-ਮੂਰ ਅਲਗੋਰਿਦਮ ਨੂੰ ਆਮ ਉਪਯੋਗਾਂ ਵਿੱਚ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸਤਰ-ਮੇਲਿੰਗ ਅਲਗੋਰਿਦਮ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. “ਸਰਚ” ਅਤੇ “ਬਦਲ” ਕਮਾਂਡਾਂ ਲਈ ਇਸਦਾ ਇਕ ਸਰਲੀਕਰਨ ਸੰਸਕਰਣ (ਜਾਂ ਸਾਰਾ ਅਲਗੋਰਿਦਮ) ਅਕਸਰ ਟੈਕਸਟ ਐਡੀਟਰਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਕੋਲ ਇਹ ਸਾਬਤ ਕਰਦਾ ਹੈ ਕਿ ਗੈਰ-ਮਿਆਦ ਦੇ ਪੈਟਰਨ ਲਈ ਪੂਰਵ ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਬਾਅਦ ਅੱਖਰਾਂ ਦੀ ਤੁਲਨਾ ਦੀ ਅਧਿਕਤਮ ਗਿਣਤੀ 3n ਨਾਲ ਘਿਰਿਆ ਹੋਇਆ ਹੈ. ਸਮੇਂ ਸਮੇਂ ਦੇ ਪੈਟਰਨ ਲਈ ਇਸ ਦਾ ਇੱਕ ਵਰਗ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਕੇਸ ਟਾਈਮ ਹੈ

ਬੋਅਰ-ਮੂਰ ਅਲਗੋਰਿਦਮ ਦੇ ਕਈ ਰੂਪ ਉਸਦੇ ਸਕਾਰਾਤਮਕ ਵਿਵਹਾਰ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਦੇ ਹਨ. ਪ੍ਰਿੰਸੀਪਲ ਤੁਲਨਾ ਦੀ ਸੰਖਿਆ ਵਿਚ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਭਾਵੀ ਹੱਲ Apostolico ਅਤੇ Giancarlo, Crochemore et alii (ਟਰਬੋ ਬੀਐਮ), ਅਤੇ Colussi (ਰਿਵਰਸ Colussi) ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ.

ਪ੍ਰਤਿਕਿਰਿਆਤਮਕ ਨਤੀਜਿਆਂ ਤੋਂ ਪਤਾ ਚੱਲਦਾ ਹੈ ਕਿ ਬਾਇਅਰ ਅਤੇ ਮੂਰ ਦੇ ਐਲਗੋਰਿਦਮ ਐਤਵਾਰ (ਤੇਜ਼ ਖੋਜ) ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ ਅਤੇ ਕ੍ਰਾਈਮੋਰ ਐਟ ਅਲੀ (ਰਿਵਰਸ ਫੈਕਟਰ ਅਤੇ ਟਰਬੋ ਰਿਵਰਸ ਫੈਕਟਰ) ਦੁਆਰਾ ਅਸਲੀ ਆਟੋਮੈਟਨ ਤੇ ਆਧਾਰਿਤ ਐਲਗੋਰਿਥਮ ਪ੍ਰੈਕਟੀਸ ਪ੍ਰੈਕਟੀਕਲ ਹਨ.

ਜ਼ੂ ਅਤੇ ਤਕਾਉਕਾ ਅਤੇ ਬੇਰੀ-ਰਵਿੰਦਰਾ ਅਲਗੋਰਿਦਮ ਬੌਇਰ-ਮਊਰ ਅਲਗੋਰਿਦਮ ਦੇ ਰੂਪ ਹਨ ਜੋ ਓ (ਸਿਗਮਾ 2) ਵਿੱਚ ਵਾਧੂ ਥਾਂ ਦੀ ਲੋੜ ਹੈ.

ਇੱਕ ਖਾਸ ਕ੍ਰਮ ਵਿੱਚ

ਦੋ ਪਹਿਲੀ ਰੇਖਿਕ ਅਨੁਕੂਲ ਜਗ੍ਹਾ ਸਤਰ-ਮੇਲਿੰਗ ਐਲਗੋਰਿਥਮ ਗਿਲਿਲ-ਸੀਈਫਰੇਜ਼ ਅਤੇ ਕ੍ਰੋਕਮੋਮਰ-ਪੈਰੀਨ (ਦੋ ਤਰਫਾ ਅਲਗੋਰਿਦਮ) ਦੇ ਕਾਰਨ ਹਨ. ਉਹ ਪੈਟਰਨਾਂ ਨੂੰ ਦੋ ਹਿੱਸਿਆਂ ਵਿਚ ਵੰਡਦੇ ਹਨ, ਉਹ ਪਹਿਲਾਂ ਪੈਟਰਨ ਦੇ ਸੱਜੇ ਹਿੱਸੇ ਨੂੰ ਖੱਬਿਓਂ ਸੱਜੇ ਪਾਸੇ ਖੋਜਦੇ ਹਨ ਅਤੇ ਫਿਰ ਜੇ ਕੋਈ ਮੇਲ ਨਹੀਂ ਹੁੰਦਾ ਤਾਂ ਉਹ ਖੱਬੇ ਪਾਸੇ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ.

Colussi ਅਤੇ Galil-Giancarlo ਦੇ ਐਲਗੋਰਿਥਮ ਦੋ ਸਮੂਹਾਂ ਵਿੱਚ ਪੈਟਰਨ ਦੀਆਂ ਪਦਾਂ ਦੇ ਭਾਗ ਨੂੰ ਵੰਡਦੇ ਹਨ. ਉਹ ਪਹਿਲਾਂ ਉਹਨਾਂ ਪੈਟਰਨ ਅੱਖਰਾਂ ਦੀ ਖੋਜ ਕਰਦੇ ਹਨ ਜੋ ਕਿ ਪਹਿਲੇ ਸਬਸੈੱਟ ਵਿਚ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਤੇ ਹਨ ਅਤੇ ਫਿਰ ਜੇ ਕੋਈ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਬਾਕੀ ਬਚੇ ਅੱਖਰਾਂ ਨੂੰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਵੱਲ ਖੋਜ ਕਰਦੇ ਹਨ. Colussi ਐਲਗੋਰਿਦਮ Knuth-Morris-Pratt ਐਲਗੋਰਿਦਮ ਵਿੱਚ ਇੱਕ ਸੁਧਾਰ ਹੈ ਅਤੇ ਸਭ ਤੋਂ ਜਿਆਦਾ ਕੇਸ ਵਿੱਚ ਜਿਆਦਾਤਰ 3 / 2n ਪਾਠ ਅੱਖਰ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ. ਗੈਲੀਲ-ਜੀਆਨਕੋਲੋ ਅਲਗੋਰਿਦਮ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕੇਸ ਵਿੱਚ ਕੋਲੁੱਸੀ ਅਲਗੋਰਿਦਮ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਜੋ ਇਸਨੂੰ ਸਭ ਤੋਂ ਮਾੜੇ ਕੇਸ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ 4 / 3N ਪਾਠ ਅੱਖਰ ਤੁਲਨਾ ਕਰਨ ਲਈ ਸਮਰੱਥ ਕਰਦਾ ਹੈ.

ਐਤਵਾਰ ਦੇ ਅਨੁਕੂਲ ਮੇਲ ਖਾਂਦੇ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਸ਼ਿਫਟ ਐਲਗੋਰਿਥਮ ਕ੍ਰਮਵਾਰ ਆਪਣੇ ਚਰਿੱਤਰ ਅਤੇ ਉਸਦੇ ਪ੍ਰਮੁੱਖ ਪਰਿਵਰਤਨ ਅਨੁਸਾਰ ਪੈਟਰਨ ਸਥਿਤੀ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹਨ.

ਖੋਜ ਛੱਡੀ ਛੱਡੋ, KMP ਜਾਓ ਖੋਜ ਅਤੇ ਅਲਫ਼ਾ ਛੱਡੋ ਖੋਜ (et alii) ਦੁਆਰਾ ਐਲਗੋਰਿਥਮਾਂ ਦੀ ਖੋਜ ਕਰੋ ਟੈਕਸਟ ਵਿੱਚ ਪੈਟਰਨ ਤੇ ਸ਼ੁਰੂਆਤੀ ਪਦਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਡੌਲਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ.

ਕਿਸੇ ਵੀ ਕ੍ਰਮ ਵਿੱਚ

ਹਾਰਸਪੁੱਲ ਅਲਗੋਰਿਦਮ ਬਾਇਅਰ-ਮਊਰ ਅਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਰੂਪ ਹੈ, ਇਹ ਉਸਦੀ ਇੱਕ ਸ਼ਿਫਟ ਫੰਕਸ਼ਨ ਅਤੇ ਪਾਠ ਅੱਖਰ ਦੀ ਤੁਲਨਾ ਕਰਨ ਵਾਲੇ ਆਦੇਸ਼ ਦੀ ਇੱਕ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਇਹ ਅਸਪਸ਼ਟ ਹੈ. ਇਹ ਹੋਰ ਸਾਰੇ ਰੂਪਾਂ ਲਈ ਵੀ ਸੱਚ ਹੈ ਜਿਵੇਂ ਕਿ ਐਤਵਾਰ ਦੀ ਤੇਜ਼ ਖੋਜ, ਹਿਊਮ ਅਤੇ ਐਤਵਾਰ ਨੂੰ ਟੂਨਡ ਬਾਇਅਰ-ਮੂਵਰ, ਸਮਿਥ ਐਲਗੋਰਿਦਮ ਅਤੇ ਰਾਏ ਐਲਗੋਰਿਥਮ.

ਪਰਿਭਾਸ਼ਾਵਾਂ

ਅਸੀਂ ਵਿਵਹਾਰਕ ਖੋਜਾਂ ਤੇ ਵਿਚਾਰ ਕਰਾਂਗੇ ਅਸੀਂ ਇਹ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਵਰਣਮਾਲਾ ASCII ਕੋਡਾਂ ਦਾ ਸੈਟ ਹੈ ਜਾਂ ਇਸਦਾ ਕੋਈ ਵੀ ਸਮੂਹ. ਅਲਗੋਰਿਦਮ ਸੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਇਸ ਲਈ ਲੰਮਾਈ ਦੀ ਲੰਬਾਈ ਦੀ ਇੱਕ ਸ਼ਬਦ W ਲਈ [w] [0], …, w [ell-1] ਅਤੇ w [ë] ਵਿੱਚ ਵਿਸ਼ੇਸ਼ ਅੰਤ ਅੱਖਰ (null character) ਹੁੰਦਾ ਹੈ ਕਿਸੇ ਵੀ ਸ਼ਬਦ ਦੇ ਅੰਦਰ ਕਿਤੇ ਵੀ ਨਹੀਂ ਹੋ ਸਕਦਾ ਪਰ ਅੰਤ ਵਿੱਚ. ਮੇਨ ਮੈਮੋਰੀ ਵਿੱਚ ਪੈਟਰਨ ਅਤੇ ਟੈਕਸਟ ਦੋਨਾਂ ਸ਼ਬਦ ਮੌਜੂਦ ਹਨ.

ਇੱਕ ਸ਼ਬਦ u ਸ਼ਬਦ ਦਾ ਇੱਕ ਅਗੇਤਰ ਹੈ w ਇੱਕ ਸ਼ਬਦ v (ਸੰਭਵ ਤੌਰ ‘ਤੇ ਖਾਲੀ) ਵਿੱਚ ਮੌਜੂਦ ਹੈ ਜਿਵੇਂ w = uv.

ਇੱਕ ਸ਼ਬਦ v ਸ਼ਬਦ ਦਾ ਪਿਛੇਤਰ ਹੈ w ਇੱਕ ਸ਼ਬਦ ਹੈ (ਸੰਭਵ ਤੌਰ ਤੇ ਖਾਲੀ) ਜਿਵੇਂ w = uv.

ਇੱਕ ਸ਼ਬਦ z ਇੱਕ ਸਬਸਟ੍ਰਿੰਗ ਜਾਂ ਸਬਵਰਡ ਜਾਂ ਇੱਕ ਸ਼ਬਦ ਦਾ ਫੈਕਟਰ ਹੈ, ਇੱਥੇ ਦੋ ਸ਼ਬਦ ਹਨ u ਅਤੇ v (ਸੰਭਵ ਤੌਰ ਤੇ ਖਾਲੀ) ਜਿਵੇਂ w = uzv.

ਇੱਕ ਪੂਰਨ ਅੰਕ p ਇੱਕ ਸ਼ਬਦ ਦੀ ਮਿਆਦ ਹੈ ਜੇਕਰ i, 0 leq i <m-p, w [i] = w [i + p] ਲਈ. ਵੀਂਦ ਦੀ ਸਭ ਤੋਂ ਛੋਟੀ ਮਿਆਦ ਨੂੰ ਅਵਧੀ ਕਹਿੰਦੇ ਹਨ, ਇਹ ਪ੍ਰਤੀ (w) ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ.

ਲੰਬਾਈ ਦੀ ਲੰਬਾਈ ਦਾ ਇੱਕ ਸ਼ਬਦ ਵਸੀਲਾ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਉਸ ਦੀ ਛੋਟੀ ਮਿਆਦ ਦੀ ਲੰਬਾਈ ell / 2 ਦੇ ਬਰਾਬਰ ਜਾਂ ਉਸ ਦੇ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਹ ਗੈਰ-ਨਿਯਮਤ ਹੁੰਦੀ ਹੈ.

ਇੱਕ ਸ਼ਬਦ w ਬੁਨਿਆਦੀ ਹੈ ਜੇ ਇਸਨੂੰ ਕਿਸੇ ਹੋਰ ਸ਼ਬਦ ਦੀ ਸ਼ਕਤੀ ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ: ਇੱਥੇ ਕੋਈ ਸ਼ਬਦ ਨਹੀਂ ਹੈ z ਅਤੇ ਕੋਈ ਪੂਰਨ ਅੰਕ k ਨਹੀਂ ਹੈ ਜਿਵੇਂ w = zk.

ਇੱਕ ਸ਼ਬਦ z ਇੱਕ ਸ਼ਬਦ w ਦੀ ਸਰਹੱਦ ਹੈ, ਜੇ ਦੋ ਸ਼ਬਦ u ਅਤੇ v ਮੌਜੂਦ ਹਨ ਜਿਵੇਂ ਕਿ w = uz = zv, z ਦੋਵੇਂ ਅਗੇਤਰ ਅਤੇ w ਦਾ ਪਿਛੇਤਰ ਹੈ. ਨੋਟ ਕਰੋ ਕਿ ਇਸ ਕੇਸ ਵਿਚ | u | = | v | ਵੀਂਡ ਦੀ ਇੱਕ ਮਿਆਦ ਹੈ

ਡਬਲਯੂ ਆਰ ਦੁਆਰਾ ਦਰਸਾਈ ਗਈ ਲੰਬਾਈ ਦੀ ਇਕ ਸ਼ਬਦ W ਦੇ ਉਲਟ w ਦਾ ਪ੍ਰਤੀਬਿੰਬ ਚਿੱਤਰ; wR = w [ell-1] w [ell-2] … w [1] w [0].

ਇਕ ਡਿਟਾਇਮਿਨਿਸਿਕ ਕੰਟਾਈਟ ਆਟੋਮੇਟੋਨ (ਡੀ.ਐੱਫ਼.ਏ.) ਏ ਚੌਆੜੀ (ਕਯੂ, ਕਯੂ0, ਟੀ, ਈ) ਹੈ ਜਿੱਥੇ:

Q ਰਾਜਾਂ ਦਾ ਇੱਕ ਸੀਮਤ ਸਮੂਹ ਹੈ;

ਪ੍ਰਸ਼ਨ ਵਿੱਚ q0 ਸ਼ੁਰੂਆਤੀ ਹਾਲਤ ਹੈ;

ਟੀ, ਕ ਸਮੂਹ ਦਾ ਸਮੂਹ, ਟਰਮੀਨਲ ਰਾਜਾਂ ਦਾ ਸੈੱਟ ਹੈ;

E, ਸਬਸੈੱਟ ਆਫ਼ (ਕ. ਸਿਗਮਾ.ਕਿਊ), ਪਰਿਵਰਤਨ ਦਾ ਸੈੱਟ ਹੈ

ਏ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀ ਭਾਸ਼ਾ L (A) ਹੇਠ ਦਿੱਤੀ ਸੈੱਟ ਹੈ:

ਮੌਜੂਦਾ ਕਿਤਾਬ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਹਰੇਕ ਸਹੀ ਸਤਰ-ਮੇਲਿੰਗ ਅਲਗੋਰਿਦਮ ਲਈ, ਪਹਿਲਾਂ ਅਸੀਂ ਆਪਣੀਆਂ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿੰਦੇ ਹਾਂ, ਫਿਰ ਅਸੀਂ ਸਮਝਾਇਆ ਕਿ ਇਹ C ਕੋਡ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ. ਉਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਇਸਦੇ ਵਿਹਾਰ ਨੂੰ ਇੱਕ ਖਾਸ ਉਦਾਹਰਨ ਤੇ ਦਿਖਾਉਂਦੇ ਹਾਂ ਜਿੱਥੇ x = GCAGAGAG ਅਤੇ y = GCATCGCAGAGATTACAGTACG. ਅਖੀਰ ਵਿੱਚ ਅਸੀਂ ਉਨ੍ਹਾਂ ਹਵਾਲਿਆਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦਿੰਦੇ ਹਾਂ ਜਿੱਥੇ ਪਾਠਕ ਹੋਰ ਵਿਸਤ੍ਰਿਤ ਪੇਸ਼ਕਾਰੀਆਂ ਅਤੇ ਅਲਗੋਰਿਦਮ ਦੇ ਸਬੂਤ ਲੱਭੇਗਾ. ਹਰ ਕੋਸ਼ਿਸ਼ ‘ਤੇ ਮੈਚਾਂ ਨੂੰ ਹਲਕੇ ਭੂਰੇ ਰੰਗ ਨਾਲ ਭਰਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਕਿ ਮਿਸਮੈਂਚਾਂ ਨੂੰ ਹਨੇਰੇ ਰੰਗ ਵਿਚ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ. ਇੱਕ ਨੰਬਰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਚਰਿੱਤਰ ਦੀ ਤੁਲਨਾ ਕੀਤੀ ਗਈ ਹੈ ਉਸ ਤੋਂ ਇਲਾਵਾ ਸਵੈ-ਚਾਲਤ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਅਲਗੋਰਿਦਮਾਂ ਨੂੰ ਛੱਡ ਕੇ, ਜਿੱਥੇ ਨੰਬਰ ਦੀ ਸਥਿਤੀ ਅੱਖਰ ਨਿਰੀਖਣ ਤੋਂ ਬਾਅਦ ਪਹੁੰਚਦੀ ਹੈ.

ਲਾਗੂ ਕਰਨ

ਇਸ ਕਿਤਾਬ ਵਿੱਚ, ਅਸੀਂ ਸੀ ਸਟ੍ਰਿੰਗਸ ਦਾ ਇਸਤੇਮਾਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਹ ਮੰਨਦੇ ਹਾਂ ਕਿ ਲੰਬਾਈ ਦੇ ਇੱਕ ਸਤਰ ਦੀ ਇੱਕ (m + 1) -th ਸੰਕੇਤ ਸ਼ਾਮਿਲ ਹੈ (ਆਮ ਤੌਰ ‘ਤੇ ਮੁੱਲ’ \ 0 ‘ਨਾਲ ਦਿੱਤਾ ਗਿਆ ਹੈ). ਨਹੀਂ ਤਾਂ ਕੁਝ ਐਲਗੋਰਿਥਮ ਸਥਾਪਨ ਕ੍ਰਮਬੱਧ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਸਤਰ ਦੇ ਅਸਲ ਆਖਰੀ ਵਰਣ ਤੋਂ ਪਰੇ ਸਥਿਤੀ ਨੂੰ ਪਹੁੰਚਣਾ ਹੋਵੇ. (ਇਸ ਖ਼ਾਸ ਬਿੰਦੂ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਲੈਬੋਰਟਰੀਜ਼ ਤੋਂ ਡੇਵਿਡ ਬੀ ਟ੍ਰੈਅਟ ਦਾ ਧੰਨਵਾਦ).

ਇਸ ਪੁਸਤਕ ਵਿੱਚ, ਅਸੀਂ ਸ਼ਾਸਤਰੀ ਸੰਦਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ. ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਪੂਰਨ ਅੰਕ ਦੀ ਇੱਕ ਲਿੰਕ ਕੀਤੀ ਸੂਚੀ ਹੈ. ਇਸ ਨੂੰ C ਵਿਚ ਪਰਿਭਾਸ਼ਤ ਕੀਤਾ ਜਾਵੇਗਾ:

  struct _cell{
    int element; 
    struct _cell *next;
  };
 
  typedef struct _cell *List;

ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਣ ਬਣਤਰ ਆਟੋਮੇਟਾ ਹਨ ਅਤੇ ਵਿਸ਼ੇਸ਼ ਤੌਰ ‘ਤੇ ਆਟੋਮਾਮੇਟ ਨੂੰ ਪ੍ਰਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ (ਅਧਿਆਇ 22 ਵੇਖੋ). ਅਸਲ ਵਿੱਚ ਆਟੋਮੇਟਾ ਗਰਾਫ਼ ਦੇ ਨਿਰਦੇਸ਼ਕ ਹਨ ਅਸੀਂ ਆਟੋਮਾਟਾ ਨੂੰ ਬਦਲਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਇੰਟਰਫੇਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:

  Graph newGraph(int v, int e); 
  Graph newAutomaton(int v, int e); 
  Graph newSuffixAutomaton(int v, int e); 
  int newVertex(Graph g); 
  int getInitial(Graph g); 
  boolean isTerminal(Graph g, int v); 
  void setTerminal(Graph g, int v); 
  int getTarget(Graph g, int v, unsigned char c); 
  void setTarget(Graph g, int v, unsigned char c, int t); 
  int getSuffixLink(Graph g, int v); 
  void setSuffixLink(Graph g, int v, int s); 
  int getLength(Graph g, int v); 
  void setLength(Graph g, int v, int ell); 
  int getPosition(Graph g, int v); 
  void setPosition(Graph g, int v, int p); 
  int getShift(Graph g, int v, unsigned char c); 
  void setShift(Graph g, int v, unsigned char c, int s); 
  void copyVertex(Graph g, int target, int source);

ਇਸ ਇੰਟਰਫੇਸ ਦਾ ਸੰਭਵ ਅਮਲ ਇਸ ਤਰ੍ਹਾਂ ਹੈ.

  struct _graph {
    int vertexNumber, 
        edgeNumber, 
        vertexCounter, 
        initial, 
        *terminal, 
        *target, 
        *suffixLink,
        *length, 
        *position, 
        *shift; 
  };
  
  typedef struct _graph *Graph; 
  typedef int boolean;
   
#define UNDEFINED -1
  
/* returns a new data structure for
   a graph with v vertices and e edges */
Graph newGraph(int v, int e) {
   Graph g;

   g = (Graph)calloc(1, sizeof(struct _graph));
   if (g == NULL)
      error("newGraph");
   g->vertexNumber  = v;
   g->edgeNumber    = e;
   g->initial       = 0;
   g->vertexCounter = 1;
   return(g);
}


/* returns a new data structure for
   a automaton with v vertices and e edges */
Graph newAutomaton(int v, int e) {
   Graph aut;

   aut = newGraph(v, e);
   aut->target = (int *)calloc(e, sizeof(int));
   if (aut->target == NULL)
      error("newAutomaton");
   aut->terminal = (int *)calloc(v, sizeof(int));
   if (aut->terminal == NULL)
      error("newAutomaton");
   return(aut);
}


/* returns a new data structure for
   a suffix automaton with v vertices and e edges */
Graph newSuffixAutomaton(int v, int e) {
   Graph aut;

   aut = newAutomaton(v, e);
   memset(aut->target, UNDEFINED, e*sizeof(int));
   aut->suffixLink = (int *)calloc(v, sizeof(int));
   if (aut->suffixLink == NULL)
      error("newSuffixAutomaton");
   aut->length = (int *)calloc(v, sizeof(int));
   if (aut->length == NULL)
      error("newSuffixAutomaton");
   aut->position = (int *)calloc(v, sizeof(int));
   if (aut->position == NULL)
      error("newSuffixAutomaton");
   aut->shift = (int *)calloc(e, sizeof(int));
   if (aut->shift == NULL)
      error("newSuffixAutomaton");
   return(aut);
}
 
 
/* returns a new data structure for
   a trie with v vertices and e edges */
Graph newTrie(int v, int e) {
   Graph aut;
 
   aut = newAutomaton(v, e);
   memset(aut->target, UNDEFINED, e*sizeof(int));
   aut->suffixLink = (int *)calloc(v, sizeof(int));
   if (aut->suffixLink == NULL)
      error("newTrie");
   aut->length = (int *)calloc(v, sizeof(int));
   if (aut->length == NULL)
      error("newTrie");
   aut->position = (int *)calloc(v, sizeof(int));
   if (aut->position == NULL)
      error("newTrie");
   aut->shift = (int *)calloc(e, sizeof(int));
   if (aut->shift == NULL)
      error("newTrie");
   return(aut);
}


/* returns a new vertex for graph g */
int newVertex(Graph g) {
   if (g != NULL && g->vertexCounter <= g->vertexNumber)
      return(g->vertexCounter++);
   error("newVertex");
}


/* returns the initial vertex of graph g */
int getInitial(Graph g) {
   if (g != NULL)
      return(g->initial);
   error("getInitial");
}


/* returns true if vertex v is terminal in graph g */
boolean isTerminal(Graph g, int v) {
   if (g != NULL && g->terminal != NULL &&
       v < g->vertexNumber)
      return(g->terminal[v]);
   error("isTerminal");
}


/* set vertex v to be terminal in graph g */
void setTerminal(Graph g, int v) {
   if (g != NULL && g->terminal != NULL &&
       v < g->vertexNumber)
      g->terminal[v] = 1;
   else
      error("isTerminal");
}


/* returns the target of edge from vertex v
   labelled by character c in graph g */
int getTarget(Graph g, int v, unsigned char c) {
   if (g != NULL && g->target != NULL &&
       v < g->vertexNumber && v*c < g->edgeNumber)
      return(g->target[v*(g->edgeNumber/g->vertexNumber) +
                       c]);
   error("getTarget");
}


/* add the edge from vertex v to vertex t
   labelled by character c in graph g */
void setTarget(Graph g, int v, unsigned char c, int t) {
   if (g != NULL && g->target != NULL &&
       v < g->vertexNumber &&
       v*c <= g->edgeNumber && t < g->vertexNumber)
      g->target[v*(g->edgeNumber/g->vertexNumber) + c] = t;
   else
      error("setTarget");
}


/* returns the suffix link of vertex v in graph g */
int getSuffixLink(Graph g, int v) {
   if (g != NULL && g->suffixLink != NULL &&
       v < g->vertexNumber)
      return(g->suffixLink[v]);
   error("getSuffixLink");
}


/* set the suffix link of vertex v
   to vertex s in graph g */
void setSuffixLink(Graph g, int v, int s) {
   if (g != NULL && g->suffixLink != NULL &&
       v < g->vertexNumber && s < g->vertexNumber)
      g->suffixLink[v] = s;
   else
      error("setSuffixLink");
}


/* returns the length of vertex v in graph g */
int getLength(Graph g, int v) {
   if (g != NULL && g->length != NULL &&
       v < g->vertexNumber)
      return(g->length[v]);
   error("getLength");
}


/* set the length of vertex v to integer ell in graph g */
void setLength(Graph g, int v, int ell) {
   if (g != NULL && g->length != NULL &&
       v < g->vertexNumber)
      g->length[v] = ell;
   else
      error("setLength");
}


/* returns the position of vertex v in graph g */
int getPosition(Graph g, int v) {
   if (g != NULL && g->position != NULL &&
       v < g->vertexNumber)
      return(g->position[v]);
   error("getPosition");
}


/* set the length of vertex v to integer ell in graph g */
void setPosition(Graph g, int v, int p) {
   if (g != NULL && g->position != NULL &&
       v < g->vertexNumber)
      g->position[v] = p;
   else
      error("setPosition");
}


/* returns the shift of the edge from vertex v
   labelled by character c in graph g */
int getShift(Graph g, int v, unsigned char c) {
   if (g != NULL && g->shift != NULL &&
       v < g->vertexNumber && v*c < g->edgeNumber)
      return(g->shift[v*(g->edgeNumber/g->vertexNumber) +
             c]);
   error("getShift");
}


/* set the shift of the edge from vertex v
   labelled by character c to integer s in graph g */
void setShift(Graph g, int v, unsigned char c, int s) {
   if (g != NULL && g->shift != NULL &&
       v < g->vertexNumber && v*c <= g->edgeNumber)
      g->shift[v*(g->edgeNumber/g->vertexNumber) + c] = s;
   else
      error("setShift");
}


/* copies all the characteristics of vertex source
   to vertex target in graph g */
void copyVertex(Graph g, int target, int source) {
   if (g != NULL && target < g->vertexNumber &&
       source < g->vertexNumber) {
      if (g->target != NULL)
         memcpy(g->target +
                target*(g->edgeNumber/g->vertexNumber),
                g->target +
                source*(g->edgeNumber/g->vertexNumber),
                (g->edgeNumber/g->vertexNumber)*
                sizeof(int));
      if (g->shift != NULL)
         memcpy(g->shift +
                target*(g->edgeNumber/g->vertexNumber),
                g->shift +
                source*(g->edgeNumber/g->vertexNumber),
                g->edgeNumber/g->vertexNumber)*
                sizeof(int));
      if (g->terminal != NULL)
         g->terminal[target] = g->terminal[source];
      if (g->suffixLink != NULL)
         g->suffixLink[target] = g->suffixLink[source];
      if (g->length != NULL)
         g->length[target] = g->length[source];
      if (g->position != NULL)
         g->position[target] = g->position[source];
   }
   else
      error("copyVertex");
}

Source: http://www-igm.univ-mlv.fr/~lecroq/string/node2.html

Copyright © 2018 Bydiscountcodes.co.uk - All Rights Reserved.

Bydiscountcodes.co.uk Powered and Managed by Agite Technologies LLP.